Files.app: Stop to use file system URLs having externalfile:// scheme origin internally.

chrome/browser/chromeos/fileapi/external_file_url_request_job.cc

 // Copyright 2014 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/fileapi/external_file_url_request_job.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/fileapi/external_file_url_util.h"
 #include "chrome/browser/extensions/api/file_handlers/mime_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
+#include "storage/browser/fileapi/external_mount_points.h"
 #include "storage/browser/fileapi/file_system_backend.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation_runner.h"
+#include "storage/browser/fileapi/isolated_context.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 namespace {
 
 const char kMimeTypeForRFC822[] = "message/rfc822";
 const char kMimeTypeForMHTML[] = "multipart/related";
 
+storage::FileSystemURL CreateIsolatedURLFromVirtualPath(
+    const storage::FileSystemContext& context,
+    const base::FilePath& virtual_path) {
+  std::string file_system_id;
+  storage::FileSystemType file_system_type;
+  base::FilePath path;
+  {
+    std::string cracked_id;
+    storage::FileSystemMountOption option;
+    storage::ExternalMountPoints::GetSystemInstance()->CrackVirtualPath(
+        virtual_path,
+        &file_system_id,
+        &file_system_type,
+        &cracked_id,
+        &path,
+        &option);
+  }
+  if (!IsExternalFileURLType(file_system_type))
+    return storage::FileSystemURL();
+  std::string register_name;
+  const std::string isolated_file_system_id =
+      storage::IsolatedContext::GetInstance()->RegisterFileSystemForPath(
+          file_system_type, file_system_id, path, &register_name);
+  storage::FileSystemURL file_system_url = context.CreateCrackedFileSystemURL(
+      GURL(""),

[mtomasz, 2014/09/29 12:47:40]

nit: Maybe just GURL()?

[hirono, 2014/09/29 13:24:02]

Done.

+      storage::kFileSystemTypeIsolated,
+      base::FilePath(isolated_file_system_id).Append(register_name));
+  DCHECK(file_system_url.is_valid());
+  return file_system_url;
+}
+
 // Helper for obtaining FileSystemContext, FileSystemURL, and mime type on the
 // UI thread.
 class URLHelper {
  public:
   // The scoped pointer to control lifetime of the instance itself. The pointer
   // is passed to callback functions and binds the lifetime of the instance to
   // the callback's lifetime.
   typedef scoped_ptr<URLHelper> Lifetime;
 
   URLHelper(void* profile_id,
@@ skipping 22 matching lines @@
     DCHECK(storage);
 
     scoped_refptr<storage::FileSystemContext> context =
         storage->GetFileSystemContext();
     DCHECK(context.get());
 
     // Obtain the absolute path in the file system.
     const base::FilePath virtual_path = ExternalFileURLToVirtualPath(url_);
 
     // Obtain the file system URL.
-    // TODO(hirono): After removing MHTML support, stop to use the special
-    // drive: scheme and use filesystem: URL directly.  crbug.com/415455
-    file_system_url_ = context->CreateCrackedFileSystemURL(
-        GURL(std::string(chrome::kExternalFileScheme) + ":"),
-        storage::kFileSystemTypeExternal,
-        virtual_path);
+    file_system_url_ = CreateIsolatedURLFromVirtualPath(*context, virtual_path);
 
     // Check if the obtained path providing external file URL or not.
-    if (FileSystemURLToExternalFileURL(file_system_url_).is_empty()) {
+    if (!file_system_url_.is_valid()) {
       ReplyResult(net::ERR_INVALID_URL);
       return;
     }
 
+    isolated_file_system_scope_.reset(
+        new ExternalFileURLRequestJob::IsolatedFileSystemScope(
+            file_system_url_.filesystem_id()));
     file_system_context_ = context;
 
     extensions::app_file_handler_util::GetMimeTypeForLocalPath(
         profile,
         file_system_url_.path(),
         base::Bind(&URLHelper::OnGotMimeTypeOnUIThread,
                    base::Unretained(this),
                    base::Passed(&lifetime)));
   }
 
   void OnGotMimeTypeOnUIThread(Lifetime lifetime,
                                const std::string& mime_type) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     mime_type_ = mime_type;
 
     if (mime_type_ == kMimeTypeForRFC822)
       mime_type_ = kMimeTypeForMHTML;
 
     ReplyResult(net::OK);
   }
 
   void ReplyResult(net::Error error) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-    BrowserThread::PostTask(BrowserThread::IO,
-                            FROM_HERE,
-                            base::Bind(callback_,
-                                       error,
-                                       file_system_context_,
-                                       file_system_url_,
-                                       mime_type_));
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(callback_,
+                   error,
+                   file_system_context_,
+                   base::Passed(&isolated_file_system_scope_),
+                   file_system_url_,
+                   mime_type_));
   }
 
   void* const profile_id_;
   const GURL url_;
   const ExternalFileURLRequestJob::HelperCallback callback_;
   scoped_refptr<storage::FileSystemContext> file_system_context_;
+  scoped_ptr<ExternalFileURLRequestJob::IsolatedFileSystemScope>
+      isolated_file_system_scope_;
   storage::FileSystemURL file_system_url_;
   std::string mime_type_;
 
   DISALLOW_COPY_AND_ASSIGN(URLHelper);
 };
 
 }  // namespace
 
+ExternalFileURLRequestJob::IsolatedFileSystemScope::IsolatedFileSystemScope(
+    const std::string& file_system_id)
+    : file_system_id_(file_system_id) {
+}
+
+ExternalFileURLRequestJob::IsolatedFileSystemScope::~IsolatedFileSystemScope() {
+  storage::IsolatedContext::GetInstance()->RevokeFileSystem(file_system_id_);
+}
+
 ExternalFileURLRequestJob::ExternalFileURLRequestJob(
     void* profile_id,
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate)
     : net::URLRequestJob(request, network_delegate),
       profile_id_(profile_id),
       remaining_bytes_(0),
       weak_ptr_factory_(this) {
 }
 
@@ skipping 38 matching lines @@
   // Owned by itself.
   new URLHelper(profile_id_,
                 request()->url(),
                 base::Bind(&ExternalFileURLRequestJob::OnHelperResultObtained,
                            weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ExternalFileURLRequestJob::OnHelperResultObtained(
     net::Error error,
     const scoped_refptr<storage::FileSystemContext>& file_system_context,
+    scoped_ptr<IsolatedFileSystemScope> isolated_file_system_scope,
     const storage::FileSystemURL& file_system_url,
     const std::string& mime_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (error != net::OK) {
     NotifyStartError(
         net::URLRequestStatus(net::URLRequestStatus::FAILED, error));
     return;
   }
 
   DCHECK(file_system_context.get());
   file_system_context_ = file_system_context;
+  isolated_file_system_scope_ = isolated_file_system_scope.Pass();
   file_system_url_ = file_system_url;
   mime_type_ = mime_type;
 
   // Check if the entry has a redirect URL.
   file_system_context_->external_backend()->GetRedirectURLForContents(
       file_system_url_,
       base::Bind(&ExternalFileURLRequestJob::OnRedirectURLObtained,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ skipping 38 matching lines @@
     return;
   }
   const int64 offset = byte_range_.first_byte_position();
   const int64 size =
       byte_range_.last_byte_position() + 1 - byte_range_.first_byte_position();
   set_expected_content_size(size);
   remaining_bytes_ = size;
 
   // Create file stream reader.
   stream_reader_ = file_system_context_->CreateFileStreamReader(
       file_system_url_, offset, size, base::Time());

[mtomasz, 2014/09/29 12:47:40]

Could you briefly explain how it works? We're passing an isolated url, right?
How does it get get a file stream reader for drive then? I'm not very sure how
isolated file systems work under the hood. How do we skip the permission check?

[hirono, 2014/09/29 13:24:02]

CreateFileStreamReader basically refers two members. file_system_url.path() and
file_system_url.mount_type();

path() refers the location of file.
It is set correctly when the file system URL is cracked (#65) by referring
isolated context's mount point.

mount_type() is always kFileSystemTypeIsolated. It is checked by IsAccessAllowed
and IsAccessAllowed always returns true for kFileSystemTypeIsolated.

So basically the CL just replaces the magic word to pass the check
(kExternalFileScheme) with kFileSystemTypeIsolated. But kFileSystemTypeIsolated
is harder to abuse than kExternalFileScheme, because isolated URLs (mount point
name part) is unpredictable.

[mtomasz, 2014/09/29 13:35:45]

Got it. Thanks for the explanation.

   if (!stream_reader_) {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_FILE_NOT_FOUND));
     return;
   }
 
   NotifyHeadersComplete();
 }
 
 void ExternalFileURLRequestJob::Kill() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   stream_reader_.reset();
+  isolated_file_system_scope_.reset();
   file_system_context_ = NULL;
   net::URLRequestJob::Kill();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 bool ExternalFileURLRequestJob::GetMimeType(std::string* mime_type) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   mime_type->assign(mime_type_);
   return !mime_type->empty();
 }
@@ skipping 56 matching lines @@
     NotifyDone(
         net::URLRequestStatus(net::URLRequestStatus::FAILED, read_result));
   }
 
   remaining_bytes_ -= read_result;
   SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status.
   NotifyReadComplete(read_result);
 }
 
 }  // namespace chromeos