Integrate external mount points to IsolatedContext

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"
@@ skipping 16 matching lines @@
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.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"
 #include "net/base/escape.h"
+#include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
 #include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_mount_point_provider.h"
+#include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 
 namespace file_handler_util {
@@ skipping 510 matching lines @@
   // Checks legitimacy of file url and grants file RO access permissions from
   // handler (target) extension and its renderer process.
   bool SetupFileAccessPermissions(const GURL& origin_file_url,
                                   FileDefinition* file) {
     if (!handler_extension_.get())
       return false;
 
     if (handler_pid_ == 0)
       return false;
 
-    GURL file_origin_url;
-    FilePath virtual_path;
-    fileapi::FileSystemType type;
-    if (!CrackFileSystemURL(origin_file_url, &file_origin_url, &type,
-                            &virtual_path)) {
-      return false;
-    }
-
-    if (type != fileapi::kFileSystemTypeExternal)
+    fileapi::FileSystemURL url(origin_file_url);
+    if (!chromeos::CrosMountPointProvider::CanHandleURL(url))
       return false;
 
     fileapi::ExternalFileSystemMountPointProvider* external_provider =
         file_system_context_->external_provider();
     if (!external_provider)
       return false;
 
-    if (!external_provider->IsAccessAllowed(file_origin_url,
-                                            type,
-                                            virtual_path)) {
+    if (!external_provider->IsAccessAllowed(url.origin(),
+                                            url.type(),
+                                            url.virtual_path())) {
       return false;
     }
 
     // Make sure this url really being used by the right caller extension.
-    if (source_url_.GetOrigin() != file_origin_url) {
+    if (source_url_.GetOrigin() != url.origin()) {
       DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
       return false;
     }
 
-    FilePath root_path =
-        external_provider->GetFileSystemRootPathOnFileThread(
-          file_origin_url,
-          fileapi::kFileSystemTypeExternal,
-          virtual_path,
-          false);     // create
-    FilePath final_file_path = root_path.Append(virtual_path);
-
     // Check if this file system entry exists first.
     base::PlatformFileInfo file_info;
 
-    bool is_gdata_file = gdata::util::IsUnderGDataMountPoint(final_file_path);
+    FilePath local_path = url.path();
+    FilePath virtual_path = url.virtual_path();
+
+    bool is_drive_file = url.type() == fileapi::kFileSystemTypeDrive;
+    DCHECK(!is_drive_file || gdata::util::IsUnderGDataMountPoint(local_path));
 
     // 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)) {
+    // found on the url.path().
+    if (!is_drive_file) {
+      if (!file_util::PathExists(local_path) ||
+          file_util::IsLink(local_path) ||
+          !file_util::GetFileInfo(local_path, &file_info)) {
         return false;
       }
     }
 
     // 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,
         fileapi::kFileSystemTypeExternal);
     file->target_file_url = GURL(base_url.spec() + virtual_path.value());
     file->virtual_path = virtual_path;
     file->is_directory = file_info.is_directory;
-    file->absolute_path = final_file_path;
+    file->absolute_path = local_path;
     return true;
   }
 
   ExtensionTaskExecutor* executor_;
   scoped_refptr<fileapi::FileSystemContext> file_system_context_;
   // Extension source URL.
   GURL source_url_;
   scoped_refptr<const Extension> handler_extension_;
   int handler_pid_;
   std::string action_id_;
@@ skipping 243 matching lines @@
         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