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 18 matching lines @@
 #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/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)) {
+    fileapi::FileSystemURL url(origin_file_url);
+    if (!url.is_valid())
       return false;
-    }
 
-    if (type != fileapi::kFileSystemTypeExternal)
+    if (!fileapi::IsCrosManagedFileSystemType(url.type()))
       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);
+    bool is_gdata_file = url.type() == fileapi::kFileSystemTypeGData;

[satorux1, 2012/08/20 03:30:23]

is_gdata_file -> is_drive_file

kFileSystemTypeGData -> kFileSystemTypeDrive

[kinuko, 2012/08/20 08:54:35]

Done.

+
+    DCHECK(!is_gdata_file || gdata::util::IsUnderGDataMountPoint(url.path()));
 
     // If the file is under gdata mount point, there is no actual file to be
-    // found on the final_file_path.
+    // found on the url.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)) {
+      if (!file_util::PathExists(url.path()) ||

[kmadhusu, 2012/08/14 18:01:13]

nit: url.path() and url.virtual_path() are called several times in the same
function. Can we store the results and re-use it?

FilePath local_path = url.path();
FilePath virtual_path = url.virtual_path();

[kinuko, 2012/08/20 08:54:35]

Done.

+          file_util::IsLink(url.path()) ||
+          !file_util::GetFileInfo(url.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);
+                                                  url.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->target_file_url = GURL(base_url.spec() + url.virtual_path().value());
+    file->virtual_path = url.virtual_path();
     file->is_directory = file_info.is_directory;
-    file->absolute_path = final_file_path;
+    file->absolute_path = url.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