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

chrome/browser/chromeos/extensions/file_handler_util.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/chromeos/extensions/file_handler_util.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 413 matching lines @@
     // If the file is under gdata mount point, there is no actual file to be
     // found on the final_file_path.
     if (!is_gdata_file) {
       if (!file_util::PathExists(final_file_path) ||
           file_util::IsLink(final_file_path) ||
           !file_util::GetFileInfo(final_file_path, &file_info)) {
         return false;
       }
     }
 
-    ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-        handler_pid_,
-        final_file_path,
-        GetAccessPermissionsForHandler(handler_extension_.get(), action_id_));
-
     // Grant access to this particular file to target extension. This will
     // ensure that the target extension can access only this FS entry and
     // prevent from traversing FS hierarchy upward.
     external_provider->GrantFileAccessToExtension(handler_extension_->id(),
                                                   virtual_path);
 
     // Output values.
     GURL target_origin_url(Extension::GetBaseURLFromExtensionId(
         handler_extension_->id()));
     GURL base_url = fileapi::GetFileSystemRootURI(target_origin_url,
@@ skipping 17 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ExecuteTasksFileSystemCallbackDispatcher);
 };
 
 FileTaskExecutor::FileTaskExecutor(Profile* profile,
                                    const GURL source_url,
                                    const std::string& extension_id,
                                    const std::string& action_id)
   : profile_(profile),
     source_url_(source_url),
     extension_id_(extension_id),
-    action_id_(action_id)
-{}
+    action_id_(action_id) {
+}
 
 FileTaskExecutor::~FileTaskExecutor() {}
 
 bool FileTaskExecutor::Execute(const std::vector<GURL>& file_urls) {
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return false;
 
   scoped_refptr<const Extension> handler =
       service->GetExtensionById(extension_id_, false);
 
   if (!handler.get())
     return false;
 
   int handler_pid = ExtractProcessFromExtensionId(handler->id(), profile_);
-  if (handler_pid < 0)
-    return false;
+  if (handler_pid <= 0) {
+    if (!handler->has_lazy_background_page())
+      return false;
+  }
 
   // Get local file system instance on file thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(
           &FileTaskExecutor::RequestFileEntryOnFileThread,
           this,
           Extension::GetBaseURLFromExtensionId(handler->id()),
           handler,
           handler_pid,
@@ skipping 17 matching lines @@
           handler,
           handler_pid,
           action_id_,
           file_urls));
 }
 
 void FileTaskExecutor::ExecuteFailedOnUIThread() {
   Done(false);
 }
 
-void FileTaskExecutor::SetupFileAccessPermissionsForGDataCache(
-    const FileDefinitionList& file_list,
-    int handler_pid) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  for (FileDefinitionList::const_iterator iter = file_list.begin();
-       iter != file_list.end();
-       ++iter) {
-    if (!gdata::util::IsUnderGDataMountPoint(iter->absolute_path))
-      continue;
-    gdata::util::SetPermissionsForGDataCacheFiles(profile_, handler_pid,
-        iter->absolute_path);
-  }
-}
-
 void FileTaskExecutor::ExecuteFileActionsOnUIThread(
     const std::string& file_system_name,
     const GURL& file_system_root,
     const FileDefinitionList& file_list,
     int handler_pid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ExtensionService* service = profile_->GetExtensionService();
   if (!service) {
     Done(false);
     return;
   }
 
   const Extension* extension = service->GetExtensionById(extension_id_, false);
   if (!extension) {
     Done(false);
     return;
   }
 
+  InitHandlerHostFileAccessPermissions(file_list, extension, action_id_);
+
+  if (handler_pid > 0) {
+    SetupPermissionsAndDispatchEvent(file_system_name, file_system_root,
+        file_list, handler_pid, NULL);
+  } else {
+    // We have to wake the handler background page before we proceed.
+    extensions::LazyBackgroundTaskQueue* queue =
+        ExtensionSystem::Get(profile_)->lazy_background_task_queue();
+    if (!queue->ShouldEnqueueTask(profile_, extension)) {
+      Done(false);
+      return;
+    }
+    queue->AddPendingTask(
+        profile_, extension_id_,
+        base::Bind(&FileTaskExecutor::SetupPermissionsAndDispatchEvent, this,
+                   file_system_name, file_system_root, file_list, handler_pid));
+  }
+}
+
+void FileTaskExecutor::SetupPermissionsAndDispatchEvent(
+    const std::string& file_system_name,
+    const GURL& file_system_root,
+    const FileDefinitionList& file_list,
+    int handler_pid_in,
+    ExtensionHost* host) {
+  int handler_pid = host ? host->render_process_host()->GetID() :
+                           handler_pid_in;
+
+  if (handler_pid <= 0) {
+    Done(false);
+    return;
+  }
+
   ExtensionEventRouter* event_router = profile_->GetExtensionEventRouter();
   if (!event_router) {
     Done(false);
     return;
   }
 
-  SetupFileAccessPermissionsForGDataCache(file_list, handler_pid);
+  SetupHandlerHostFileAccessPermissions(handler_pid);
 
   scoped_ptr<ListValue> event_args(new ListValue());
   event_args->Append(Value::CreateStringValue(action_id_));
   DictionaryValue* details = new DictionaryValue();
   event_args->Append(details);
   // Get file definitions. These will be replaced with Entry instances by
   // chromeHidden.Event.dispatchJSON() method from even_binding.js.
   ListValue* files_urls = new ListValue();
   details->Set("entries", files_urls);
   for (FileDefinitionList::const_iterator iter = file_list.begin();
@@ skipping 15 matching lines @@
   }
 
   UpdateFileHandlerUsageStats(profile_, MakeTaskID(extension_id_, action_id_));
 
   std::string json_args;
   base::JSONWriter::Write(event_args.get(), &json_args);
   event_router->DispatchEventToExtension(
       extension_id_, std::string("fileBrowserHandler.onExecute"),
       json_args, profile_,
       GURL());
+
   Done(true);
 }
 
+void FileTaskExecutor::InitHandlerHostFileAccessPermissions(
+    const FileDefinitionList& file_list,
+    const Extension* handler_extension,
+    const std::string& action_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  for (FileDefinitionList::const_iterator iter = file_list.begin();
+       iter != file_list.end();
+       ++iter) {
+    // Setup permission for file's absolute file.
+    handler_host_permissions_.push_back(std::make_pair(
+        iter->absolute_path,
+        GetAccessPermissionsForHandler(handler_extension, action_id)));
+
+    if (!gdata::util::IsUnderGDataMountPoint(iter->absolute_path))
+      continue;
+
+    // If the file is on gdata mount point, we'll have to give handler host
+    // permissions for file's gdata cache paths.
+    // This has to be called on UI thread.
+    gdata::util::InsertGDataCachePathsPermissions(profile_, iter->absolute_path,
+        &handler_host_permissions_);
+  }
+}
+
+void FileTaskExecutor::SetupHandlerHostFileAccessPermissions(int handler_pid) {
+  for (size_t i = 0; i < handler_host_permissions_.size(); i++) {
+    content::ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
+        handler_pid,
+        handler_host_permissions_[i].first,
+        handler_host_permissions_[i].second);
+  }
+
+  // We don't need this anymore.
+  handler_host_permissions_.clear();
+}
+
 } // namespace file_handler_util