Use ExternalFileSystemBackend in the DriveURLRequestJob.

chrome/browser/chromeos/drive/drive_url_request_job.cc

 // Copyright 2013 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/drive/drive_url_request_job.h"
 
 #include <string>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "chrome/browser/chromeos/drive/drive.pb.h"
-#include "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
-#include "chrome/browser/chromeos/drive/file_system_interface.h"
+
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/file_system_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/file_system_backend.h"
+#include "storage/browser/fileapi/file_system_context.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace {
-
-struct MimeTypeReplacement {
-  const char* original_type;
-  const char* new_type;
-};
-
-const MimeTypeReplacement kMimeTypeReplacements[] = {
-  {"message/rfc822", "multipart/related"}  // Fixes MHTML
-};
-
-std::string FixupMimeType(const std::string& type) {
-  for (size_t i = 0; i < arraysize(kMimeTypeReplacements); i++) {
-    if (type == kMimeTypeReplacements[i].original_type)
-      return kMimeTypeReplacements[i].new_type;
-  }
-  return type;
+// Obtains Profile from |profile_id|. Returns NULL on failure.
+Profile* GetProfile(void* profile_id) {
+  // |profile_id| needs to be checked with ProfileManager::IsValidProfile
+  // before using it.
+  Profile* const profile = reinterpret_cast<Profile*>(profile_id);
+  if (!g_browser_process->profile_manager()->IsValidProfile(profile))
+    return NULL;
+  return profile;
 }
 
+// Obtains file system context from |profile|. Returns NULL on failure.
+storage::FileSystemContext* GetFileSystemContext(Profile* profile) {
+  content::StoragePartition* const storage =
+      content::BrowserContext::GetDefaultStoragePartition(profile);
+  if (!storage)
+    return NULL;
+  storage::FileSystemContext* const context = storage->GetFileSystemContext();
+  return context;
+}
 }  // namespace
 
 DriveURLRequestJob::DriveURLRequestJob(
-    const FileSystemGetter& file_system_getter,
-    base::SequencedTaskRunner* file_task_runner,
+    void* profile_id,
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate)
     : net::URLRequestJob(request, network_delegate),
-      file_system_getter_(file_system_getter),
-      file_task_runner_(file_task_runner),
+      profile_id_(profile_id),
       weak_ptr_factory_(this) {
 }
 
 void DriveURLRequestJob::SetExtraRequestHeaders(
     const net::HttpRequestHeaders& headers) {
   std::string range_header;
   if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
     // Note: We only support single range requests.
     std::vector<net::HttpByteRange> ranges;
     if (net::HttpUtil::ParseRangeHeader(range_header, &ranges) &&
@@ skipping 15 matching lines @@
 
   // We only support GET request.
   if (request()->method() != "GET") {
     LOG(WARNING) << "Failed to start request: "
                  << request()->method() << " method is not supported";
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_METHOD_NOT_SUPPORTED));
     return;
   }
 
-  base::FilePath drive_file_path(util::DriveURLToFilePath(request_->url()));
-  if (drive_file_path.empty()) {
-    // Not a valid url.
+  // Obtain profile.
+  Profile* const profile = GetProfile(profile_id_);
+  if (!profile) {
+    NotifyStartError(
+        net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
+    return;
+  }
+
+  // Obtain file system context.
+  storage::FileSystemContext* const context = GetFileSystemContext(profile);
+  if (!context) {
+    NotifyStartError(
+        net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
+    return;
+  }
+
+  if (!request()->url().SchemeIs(chrome::kDriveScheme)) {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_INVALID_URL));
     return;
   }
 
-  // Initialize the stream reader.
-  stream_reader_.reset(
-      new DriveFileStreamReader(file_system_getter_, file_task_runner_.get()));
-  stream_reader_->Initialize(
-      drive_file_path,
-      byte_range_,
-      base::Bind(&DriveURLRequestJob::OnDriveFileStreamReaderInitialized,
+  storage::ExternalFileSystemBackend* const backend =
+      context->external_backend();
+  if (!backend) {

[mtomasz, 2014/09/12 05:41:23]

Can it ever happen? If not, then DCHECK is enough.

[hirono, 2014/09/12 07:02:15]

Done.

+    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                           net::ERR_INVALID_URL));
+    return;
+  }
+
+  // Obtain the absolute path in the file system.
+  base::FilePath path = drive::util::GetDriveMountPointPath(profile);
+  drive::util::GetDriveGrandRootPath().AppendRelativePath(
+      util::DriveURLToFilePath(request()->url()), &path);
+
+  // Obtain the virtual path.
+  base::FilePath virtual_path;
+  if (!backend->GetVirtualPath(path, &virtual_path)) {
+    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                           net::ERR_INVALID_URL));
+    return;
+  }
+
+  // Obtain the file system URL.
+  file_system_url_ = context->CreateCrackedFileSystemURL(
+      GURL(std::string(chrome::kDriveScheme) + ":"),
+      storage::kFileSystemTypeExternal,

[mtomasz, 2014/09/12 05:41:23]

We're creating a URL like: filesystem:drive:foobar while your doc specifies
drive:foobar (or externalfile:foobar). Two different urls for the same thing. Is
it all right?

[hirono, 2014/09/12 07:02:15]

This is a difficult point. But we need to generate filesystem URL internally
because the FileSystemBackend takes the URL to refer a file.

[mtomasz, 2014/09/12 08:24:54]

Is it secure? What if an extension which doesn't have access to some drive files
uses such malformed url? Can it skip permission checks?

[hirono, 2014/09/16 02:15:14]

This is secure because:

1. If the opener does not have drive: scheme, the operations (XHR, resolving
URL) are forbidden by cross domain policy.
2. Besides filesystem:drive:/ is not parsed from GURL directly because it does
not have standard scheme. So we cannot do the operation even from drive:xxxx
files.
https://code.google.com/p/chromium/codesearch#chromium/src/url/third_party/mo...

+      virtual_path);
+
+  // Prepare offset.
+  int64 offset = byte_range_.first_byte_position();
+  if (offset < 0)
+    offset = 0;
+
+  // Create file stream reader.
+  stream_reader_ =
+      context->CreateFileStreamReader(file_system_url_, offset, base::Time());
+  if (!stream_reader_) {
+    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                           net::ERR_FILE_NOT_FOUND));
+    return;
+  }
+
+  // Detect mime type from the extension.
+  net::GetMimeTypeFromExtension(file_system_url_.virtual_path().Extension(),
+                                &mime_type_);
+  if (mime_type_.empty() &&
+      file_system_url_.virtual_path().Extension() == ".mhtml") {
+    mime_type_ = "multipart/related";
+  }
+
+  // Check if the entry has a redirect URL.
+  backend->GetRedirectURLForContents(
+      file_system_url_,
+      base::Bind(&DriveURLRequestJob::OnRedirectURLObtained,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+void DriveURLRequestJob::OnRedirectURLObtained(const GURL& redirect_url) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  redirect_url_ = redirect_url;
+  NotifyHeadersComplete();
+}
+
 void DriveURLRequestJob::Kill() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   stream_reader_.reset();
   net::URLRequestJob::Kill();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 bool DriveURLRequestJob::GetMimeType(std::string* mime_type) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (!entry_) {
-    return false;
-  }
-
-  mime_type->assign(
-      FixupMimeType(entry_->file_specific_info().content_mime_type()));
+  mime_type->assign(mime_type_);
   return !mime_type->empty();
 }
 
 bool DriveURLRequestJob::IsRedirectResponse(
     GURL* location, int* http_status_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  if (!entry_ || !entry_->file_specific_info().is_hosted_document()) {
+  if (redirect_url_.is_empty())
     return false;
-  }
 
   // Redirect a hosted document.
-  *location = GURL(entry_->file_specific_info().alternate_url());
+  *location = redirect_url_;
   const int kHttpFound = 302;
   *http_status_code = kHttpFound;
   return true;
 }
 
 bool DriveURLRequestJob::ReadRawData(
     net::IOBuffer* buf, int buf_size, int* bytes_read) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(stream_reader_ && stream_reader_->IsInitialized());
+  DCHECK(stream_reader_);
 
-  int result = stream_reader_->Read(
-      buf, buf_size,
-      base::Bind(&DriveURLRequestJob::OnReadCompleted,
-                 weak_ptr_factory_.GetWeakPtr()));
+  const int result =
+      stream_reader_->Read(buf,
+                           buf_size,
+                           base::Bind(&DriveURLRequestJob::OnReadCompleted,
+                                      weak_ptr_factory_.GetWeakPtr()));
 
   if (result == net::ERR_IO_PENDING) {
     // The data is not yet available.
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
     return false;
   }
   if (result < 0) {
     // An error occurs.
     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
     return false;
   }
 
   // Reading has been finished immediately.
   *bytes_read = result;
   return true;
 }
 
 DriveURLRequestJob::~DriveURLRequestJob() {
 }
 
-void DriveURLRequestJob::OnDriveFileStreamReaderInitialized(
-    int error, scoped_ptr<ResourceEntry> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(stream_reader_);
-
-  if (error != FILE_ERROR_OK) {
-    NotifyStartError(
-        net::URLRequestStatus(net::URLRequestStatus::FAILED, error));
-    return;
-  }
-
-  DCHECK(entry && entry->has_file_specific_info());
-  entry_ = entry.Pass();
-
-  if (!entry_->file_specific_info().is_hosted_document()) {
-    // We don't need to set content size for hosted documents,
-    // because it will be redirected.
-    set_expected_content_size(entry_->file_info().size());
-  }
-
-  NotifyHeadersComplete();
-}
-
 void DriveURLRequestJob::OnReadCompleted(int read_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (read_result < 0) {
     DCHECK_NE(read_result, net::ERR_IO_PENDING);
     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                      read_result));
   }
 
   SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status.
   NotifyReadComplete(read_result);
 }
 
 }  // namespace drive