Use file thread when converting paths to absolute when loading apps.

apps/launcher.cc

 // Copyright 2013 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/launcher.h"
 
 #include "apps/browser/api/app_runtime/app_runtime_api.h"
 #include "apps/browser/file_handler_util.h"
 #include "apps/common/api/app_runtime.h"
 #include "base/command_line.h"
@@ skipping 45 matching lines @@
 using extensions::Extension;
 using extensions::ExtensionHost;
 using extensions::ExtensionSystem;
 
 namespace apps {
 
 namespace {
 
 const char kFallbackMimeType[] = "application/octet-stream";
 
-bool MakePathAbsolute(const base::FilePath& current_directory,
-                      base::FilePath* file_path) {
+bool DoMakePathAbsolute(const base::FilePath& current_directory,
+                        base::FilePath* file_path) {
   DCHECK(file_path);
   if (file_path->IsAbsolute())
     return true;
 
   if (current_directory.empty()) {
     *file_path = base::MakeAbsoluteFilePath(*file_path);
     return !file_path->empty();
   }
 
   if (!current_directory.IsAbsolute())
     return false;
 
   *file_path = current_directory.Append(*file_path);
   return true;
 }
 
-bool GetAbsolutePathFromCommandLine(const CommandLine& command_line,
-                                    const base::FilePath& current_directory,
-                                    base::FilePath* path) {
-  if (!command_line.GetArgs().size())
-    return false;
-
-  base::FilePath relative_path(command_line.GetArgs()[0]);
-  base::FilePath absolute_path(relative_path);
-  if (!MakePathAbsolute(current_directory, &absolute_path)) {
-    LOG(WARNING) << "Cannot make absolute path from " << relative_path.value();
-    return false;
-  }
-  *path = absolute_path;
-  return true;
-}
-
 // Helper method to launch the platform app |extension| with no data. This
 // should be called in the fallback case, where it has been impossible to
 // load or obtain file launch data.
 void LaunchPlatformAppWithNoData(Profile* profile, const Extension* extension) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AppEventRouter::DispatchOnLaunchedEvent(profile, extension);
 }
 
 // Class to handle launching of platform apps to open a specific path.
 // An instance of this class is created for each launch. The lifetime of these
 // instances is managed by reference counted pointers. As long as an instance
 // has outstanding tasks on a message queue it will be retained; once all
 // outstanding tasks are completed it will be deleted.
 class PlatformAppPathLauncher
     : public base::RefCountedThreadSafe<PlatformAppPathLauncher> {
  public:
   PlatformAppPathLauncher(Profile* profile,
                           const Extension* extension,
                           const base::FilePath& file_path)
       : profile_(profile), extension_(extension), file_path_(file_path) {}
 
   void Launch() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (file_path_.empty()) {
       LaunchPlatformAppWithNoData(profile_, extension_);
       return;
     }
 
     DCHECK(file_path_.IsAbsolute());
 
     if (HasFileSystemWritePermission(extension_)) {
       std::vector<base::FilePath> paths;
       paths.push_back(file_path_);
       CheckWritableFiles(
           paths,
           profile_,
           false,
           base::Bind(&PlatformAppPathLauncher::OnFileValid, this),
           base::Bind(&PlatformAppPathLauncher::OnFileInvalid, this));
       return;
     }
 
     OnFileValid();
   }
 
   void LaunchWithHandler(const std::string& handler_id) {
     handler_id_ = handler_id;
     Launch();
   }
 
+  void LaunchWithRelativePath(const base::FilePath& current_directory) {
+    BrowserThread::PostTask(
+        BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&PlatformAppPathLauncher::MakePathAbsolute,
+                   this,
+                   current_directory));
+  }
+
  private:
   friend class base::RefCountedThreadSafe<PlatformAppPathLauncher>;
 
   virtual ~PlatformAppPathLauncher() {}
 
+  void MakePathAbsolute(const base::FilePath& current_directory) {
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
+    if (!DoMakePathAbsolute(current_directory, &file_path_)) {
+      LOG(WARNING) << "Cannot make absolute path from " << file_path_.value();
+      file_path_ = base::FilePath();
+    }
+
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&PlatformAppPathLauncher::Launch, this));
+  }
+
   void OnFileValid() {
 #if defined(OS_CHROMEOS)
     if (drive::util::IsUnderDriveMountPoint(file_path_)) {
       PlatformAppPathLauncher::GetMimeTypeAndLaunchForDriveFile();
       return;
     }
 #endif
 
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&PlatformAppPathLauncher::GetMimeTypeAndLaunch, this));
   }
 
   void OnFileInvalid(const base::FilePath& /* error_path */) {
     LaunchWithNoLaunchData();
   }
 
   void GetMimeTypeAndLaunch() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
     // If the file doesn't exist, or is a directory, launch with no launch data.
     if (!base::PathExists(file_path_) ||
         base::DirectoryExists(file_path_)) {
       LOG(WARNING) << "No file exists with path " << file_path_.value();
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
               &PlatformAppPathLauncher::LaunchWithNoLaunchData, this));
       return;
     }
 
@@ skipping 13 matching lines @@
       if (mime_type.empty())
         mime_type = kFallbackMimeType;
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
             &PlatformAppPathLauncher::LaunchWithMimeType, this, mime_type));
   }
 
 #if defined(OS_CHROMEOS)
   void GetMimeTypeAndLaunchForDriveFile() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     drive::FileSystemInterface* file_system =
         drive::util::GetFileSystemByProfile(profile_);
     if (!file_system) {
       LaunchWithNoLaunchData();
       return;
     }
 
     file_system->GetFile(
         drive::util::ExtractDrivePath(file_path_),
         base::Bind(&PlatformAppPathLauncher::OnGotDriveFile, this));
   }
 
   void OnGotDriveFile(drive::FileError error,
                       const base::FilePath& file_path,
                       scoped_ptr<drive::ResourceEntry> entry) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (error != drive::FILE_ERROR_OK ||
         !entry || entry->file_specific_info().is_hosted_document()) {
       LaunchWithNoLaunchData();
       return;
     }
 
     const std::string& mime_type =
         entry->file_specific_info().content_mime_type();
     LaunchWithMimeType(mime_type.empty() ? kFallbackMimeType : mime_type);
@@ skipping 67 matching lines @@
                         host->render_process_host()->GetID(),
                         file_path_,
                         false);
     AppEventRouter::DispatchOnLaunchedEventWithFileEntry(
         profile_, extension_, handler_id_, mime_type, file_entry);
   }
 
   // The profile the app should be run in.
   Profile* profile_;
   // The extension providing the app.
+  // TODO(benwells): Hold onto the extension ID instead of a pointer as it
+  // is possible the extension will be unloaded while we're doing our thing.
+  // See http://crbug.com/372270 for details.
   const Extension* extension_;
   // The path to be passed through to the app.
-  const base::FilePath file_path_;
+  base::FilePath file_path_;
   // The ID of the file handler used to launch the app.
   std::string handler_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppPathLauncher);
 };
 
 }  // namespace
 
 void LaunchPlatformAppWithCommandLine(Profile* profile,
                                       const Extension* extension,
                                       const CommandLine& command_line,
                                       const base::FilePath& current_directory) {
   // An app with "kiosk_only" should not be installed and launched
   // outside of ChromeOS kiosk mode in the first place. This is a defensive
   // check in case this scenario does occur.
   if (extensions::KioskModeInfo::IsKioskOnly(extension)) {
     bool in_kiosk_mode = false;
 #if defined(OS_CHROMEOS)
     chromeos::UserManager* user_manager = chromeos::UserManager::Get();
     in_kiosk_mode = user_manager && user_manager->IsLoggedInAsKioskApp();
 #endif
     if (!in_kiosk_mode) {
       LOG(ERROR) << "App with 'kiosk_only' attribute must be run in "
           << " ChromeOS kiosk mode.";
       NOTREACHED();
       return;
     }
   }
 
-  base::FilePath path;
-  if (!GetAbsolutePathFromCommandLine(command_line, current_directory, &path)) {
+  if (command_line.GetArgs().empty()) {
     LaunchPlatformAppWithNoData(profile, extension);
     return;
   }
 
-  // TODO(benwells): add a command-line argument to provide a handler ID.
-  LaunchPlatformAppWithPath(profile, extension, path);
+  base::FilePath file_path(command_line.GetArgs()[0]);
+  scoped_refptr<PlatformAppPathLauncher> launcher =
+      new PlatformAppPathLauncher(profile, extension, file_path);
+  launcher->LaunchWithRelativePath(current_directory);
 }
 
 void LaunchPlatformAppWithPath(Profile* profile,
                                const Extension* extension,
                                const base::FilePath& file_path) {
-  // launcher will be freed when nothing has a reference to it. The message
-  // queue will retain a reference for any outstanding task, so when the
-  // launcher has finished it will be freed.
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, extension, file_path);
   launcher->Launch();
 }
 
 void LaunchPlatformApp(Profile* profile, const Extension* extension) {
   LaunchPlatformAppWithCommandLine(profile,
                                    extension,
                                    CommandLine(CommandLine::NO_PROGRAM),
                                    base::FilePath());
@@ skipping 34 matching lines @@
 void LaunchPlatformAppWithUrl(Profile* profile,
                               const Extension* extension,
                               const std::string& handler_id,
                               const GURL& url,
                               const GURL& referrer_url) {
   AppEventRouter::DispatchOnLaunchedEventWithUrl(
       profile, extension, handler_id, url, referrer_url);
 }
 
 }  // namespace apps