Fix filesystem API file_handlers to work for drive on ChromeOS.

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 11 matching lines @@
 #include "chrome/common/extensions/extension_messages.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/web_contents.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/isolated_context.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/drive/drive_file_error.h"
+#include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
+#include "chrome/browser/chromeos/drive/drive_file_system_util.h"
+#include "chrome/browser/chromeos/drive/drive_system_service.h"
+#endif
+
 using content::BrowserThread;
 using extensions::app_file_handler_util::FileHandlerForId;
 using extensions::app_file_handler_util::FileHandlerCanHandleFileWithMimeType;
 using extensions::app_file_handler_util::FirstFileHandlerForMimeType;
 
 namespace extensions {
 
 namespace {
 
 bool MakePathAbsolute(const base::FilePath& current_directory,
@@ skipping 43 matching lines @@
 // 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),
+        file_system_type_(fileapi::kFileSystemTypeUnknown),
         handler_id_("") {}
 
   void Launch() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (file_path_.empty()) {
       LaunchPlatformAppWithNoData(profile_, extension_);
       return;
     }
 
     DCHECK(file_path_.IsAbsolute());
+#if defined(OS_CHROMEOS)
+    if (drive::util::IsUnderDriveMountPoint(file_path_)) {
+      file_system_type_ = fileapi::kFileSystemTypeDrive;
+      GetMimeTypeAndLaunchForDriveFile();
+      return;
+    }
+#endif
+    file_system_type_ = fileapi::kFileSystemTypeNativeLocal;
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
             &PlatformAppPathLauncher::GetMimeTypeAndLaunch, this));
   }
 
   void LaunchWithHandler(const std::string& handler_id) {
     handler_id_ = handler_id;
     Launch();
   }
 
  private:
@@ skipping 19 matching lines @@
       LOG(WARNING) << "Could not obtain MIME type for "
                    << file_path_.value();
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
               &PlatformAppPathLauncher::LaunchWithNoLaunchData, this));
       return;
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
             &PlatformAppPathLauncher::LaunchWithMimeType, this, mime_type));
   }
+#if defined(OS_CHROMEOS)
+  void GetMimeTypeAndLaunchForDriveFile() {

[benwells, 2013/03/04 01:27:39]

Can this run on any thread? It is currently on UI, if that's where it needs to
be it should have a DCHECK for that. If it can run anywhere maybe a comment
saying it is on the UI thread is warranted.

[tbarzic, 2013/03/06 01:45:10]

It _must_ run on UI thread, added DCHECK.

+    drive::DriveSystemService* service =
+        drive::DriveSystemServiceFactory::FindForProfile(profile_);
+    if (!service) {
+      LaunchWithNoLaunchData();
+      return;
+    }
+
+    service->file_system()->GetFileByPath(
+        drive::util::ExtractDrivePath(file_path_),
+        base::Bind(&PlatformAppPathLauncher::OnGotDriveFile, this));
+  }
+
+  void OnGotDriveFile(drive::DriveFileError error,

[benwells, 2013/03/04 01:27:39]

Same question here about threads. This file is pretty confusing with all the
thread bouncing, so anything to help with that is good.

[tbarzic, 2013/03/06 01:45:10]

Done.

+                      const base::FilePath& file_path,
+                      const std::string& mime_type,
+                      drive::DriveFileType file_type) {
+    if (error != drive::DRIVE_FILE_OK || mime_type.empty() ||
+        file_type != drive::REGULAR_FILE) {
+      LaunchWithNoLaunchData();
+      return;
+    }
+
+    LaunchWithMimeType(mime_type);
+  }
+#endif  // defined(OS_CHROMEOS)
 
   void LaunchWithNoLaunchData() {
     // This method is required as an entry point on the UI thread.
     LaunchPlatformAppWithNoData(profile_, extension_);
   }
 
   void LaunchWithMimeType(const std::string& mime_type) {
     // Find file handler from the platform app for the file being opened.
     const FileHandlerInfo* handler = NULL;
     if (!handler_id_.empty())
@@ skipping 56 matching lines @@
     // regranted, as this would overwrite any other permissions which the
     // renderer may already have.
     if (!policy->CanReadFile(renderer_id, file_path_))
       policy->GrantReadFile(renderer_id, file_path_);
 
     std::string registered_name;
     fileapi::IsolatedContext* isolated_context =
         fileapi::IsolatedContext::GetInstance();
     DCHECK(isolated_context);
     std::string filesystem_id = isolated_context->RegisterFileSystemForPath(
-        fileapi::kFileSystemTypeNativeLocal, file_path_, &registered_name);
+        file_system_type_, file_path_, &registered_name);

[benwells, 2013/03/04 01:27:39]

There will need to be a similar type of addition to the file_system_api code.

[tbarzic, 2013/03/06 01:45:10]

yes, I know.. or fileapi layer should be changed so using
kFileSystemTypeNativeLocal works for all isolated fs' registered here (and
determining the file system type on cros file system is done before/while
executing filesystem operations)

[kinaba, 2013/03/06 02:00:42]

I feel it a little strange that the client code of IsolatedContext needs to
differentiate Drive and Native paths by itself.
(Or if it needs to specify kFileSystemTypeNativeLocal for Drive paths even.)

Can't we refactor the stuffs to allow fileapi::kFileSystemTypeExternal to be
specified here?
I'm guessing we can if we employ recursive cracking of URL.

[tbarzic, 2013/03/06 02:13:00]

yeah, I agree, that's the biggest issue I have with this.. it seems recursive
cracking on URL is probably the way to go.. I'm a bit busy with some more
pressing bugs, but I think I'll be able to return to this some time next week..

and yeah using kFileSystemNativeLocal here seems a bit confusing, we should
probably use another constant to declare this type (but I don't think
kFileSystemTypeExternal is the best choice either)

     // Granting read file system permission as well to allow file-system
     // read operations.
     policy->GrantReadFileSystem(renderer_id, filesystem_id);
 
     AppEventRouter::DispatchOnLaunchedEventWithFileEntry(
         profile_, extension_, handler_id_, mime_type, filesystem_id,
         registered_name);
   }
 
   // The profile the app should be run in.
   Profile* profile_;
   // The extension providing the app.
   const Extension* extension_;
   // The path to be passed through to the app.
   const base::FilePath file_path_;
+  // The file system type for the path passed through to the app.
+  fileapi::FileSystemType file_system_type_;
   // The ID of the file handler used to launch the app.
   std::string handler_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppPathLauncher);
 };
 
 }  // namespace
 
 void LaunchPlatformApp(Profile* profile,
                        const Extension* extension,
@@ skipping 23 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);
 }
 
 }  // namespace extensions