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 53 matching lines @@
         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_)) {
+      GetMimeTypeAndLaunchForDriveFile();
+      return;
+    }
+#endif
+
     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 20 matching lines @@
                    << 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() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+    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,
+                      const base::FilePath& file_path,
+                      const std::string& mime_type,
+                      drive::DriveFileType file_type) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+    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())
       handler = FileHandlerForId(*extension_, handler_id_);
@@ skipping 114 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