Fixed file/directory url resolution for external mount point provider.

webkit/fileapi/file_system_url_request_job.cc

 // Copyright (c) 2011 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 "webkit/fileapi/file_system_url_request_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
@@ skipping 32 matching lines @@
 
   // Tell WebKit never to cache this content.
   std::string cache_control(net::HttpRequestHeaders::kCacheControl);
   cache_control.append(": no-cache");
   headers->AddHeader(cache_control);
 
   return headers;
 }
 
 FileSystemURLRequestJob::FileSystemURLRequestJob(
-    URLRequest* request, FileSystemPathManager* path_manager,
+    URLRequest* request, FileSystemContext* file_system_context,
     scoped_refptr<base::MessageLoopProxy> file_thread_proxy)
-    : URLRequestJob(request),
-      path_manager_(path_manager),
+    : FileSystemURLRequestJobBase(request, file_system_context,
+                                  file_thread_proxy),
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &FileSystemURLRequestJob::DidRead)),
       stream_(NULL),
       is_directory_(false),
-      remaining_bytes_(0),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
-      file_thread_proxy_(file_thread_proxy) {
+      remaining_bytes_(0) {
 }
 
 FileSystemURLRequestJob::~FileSystemURLRequestJob() {
   // Since we use the two-arg constructor of FileStream, we need to call Close()
   // manually: ~FileStream won't call it for us.
   if (stream_ != NULL)
     stream_->Close();
 }
 
 void FileSystemURLRequestJob::Start() {
   MessageLoop::current()->PostTask(FROM_HERE,
       method_factory_.NewRunnableMethod(
           &FileSystemURLRequestJob::StartAsync));
 }
 
 void FileSystemURLRequestJob::Kill() {
   if (stream_ != NULL) {
     stream_->Close();
     stream_.reset(NULL);
   }
-
   URLRequestJob::Kill();
   callback_factory_.RevokeAll();
 }
 
 bool FileSystemURLRequestJob::ReadRawData(net::IOBuffer* dest, int dest_size,
                                           int *bytes_read) {
   DCHECK_NE(dest_size, 0);
   DCHECK(bytes_read);
   DCHECK_GE(remaining_bytes_, 0);
 
@@ skipping 45 matching lines @@
       else {
         // We don't support multiple range requests in one single URL request.
         // TODO(adamk): decide whether we want to support multiple range
         // requests.
         NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
       }
     }
   }
 }
 
+void FileSystemURLRequestJob::DidGetLocalPath(const FilePath& local_path) {
+  absolute_file_path_ = local_path;
+  base::FileUtilProxy::GetFileInfo(file_thread_proxy_, absolute_file_path_,
+      callback_factory_.NewCallback(&FileSystemURLRequestJob::DidResolve));
+}
+
 void FileSystemURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
   if (response_info_.get())
     *info = *response_info_;
 }
 
 int FileSystemURLRequestJob::GetResponseCode() const {
   if (response_info_.get())
     return 200;
   return URLRequestJob::GetResponseCode();
 }
 
-void FileSystemURLRequestJob::StartAsync() {
-  GURL origin_url;
-  FileSystemType type;
-  if (!CrackFileSystemURL(request_->url(), &origin_url, &type,
-                          &relative_file_path_)) {
-    NotifyFailed(net::ERR_INVALID_URL);
-    return;
-  }
-
-  path_manager_->GetFileSystemRootPath(
-      origin_url, type, false,  // create
-      callback_factory_.NewCallback(&FileSystemURLRequestJob::DidGetRootPath));
-}
-
-void FileSystemURLRequestJob::DidGetRootPath(bool success,
-                                             const FilePath& root_path,
-                                             const std::string& name) {
-  if (!success) {
-    NotifyFailed(net::ERR_FILE_NOT_FOUND);
-    return;
-  }
-
-  absolute_file_path_ = root_path.Append(relative_file_path_);
-
-  base::FileUtilProxy::GetFileInfo(file_thread_proxy_, absolute_file_path_,
-      callback_factory_.NewCallback(&FileSystemURLRequestJob::DidResolve));
-}
-
 void FileSystemURLRequestJob::DidResolve(base::PlatformFileError error_code,
     const base::PlatformFileInfo& file_info) {
   // We may have been orphaned...
   if (!request_)
     return;
 
   // We use FileSystemURLRequestJob to handle files as well as directories
   // without trailing slash.
   // If a directory does not exist, we return ERR_FILE_NOT_FOUND. Otherwise,
   // we will append trailing slash and redirect to FileDirJob.
@@ skipping 24 matching lines @@
     NotifyFailed(error_code);
     return;
   }
 
   stream_.reset(new net::FileStream(file.ReleaseValue(), kFileFlags));
 
   remaining_bytes_ = byte_range_.last_byte_position() -
                      byte_range_.first_byte_position() + 1;
   DCHECK_GE(remaining_bytes_, 0);
 
+  // TODO(adamk): Please remove this ScopedAllowIO once we support async seek on
+  // FileStream.
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   // Do the seek at the beginning of the request.
   if (remaining_bytes_ > 0 &&
       byte_range_.first_byte_position() != 0 &&
       byte_range_.first_byte_position() !=
           stream_->Seek(net::FROM_BEGIN, byte_range_.first_byte_position())) {
     NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
     return;
   }
 
   set_expected_content_size(remaining_bytes_);
@@ skipping 27 matching lines @@
     GURL::Replacements replacements;
     replacements.SetPathStr(new_path);
     *location = request_->url().ReplaceComponents(replacements);
     *http_status_code = 301;  // simulate a permanent redirect
     return true;
   }
 
   return false;
 }
 
-void FileSystemURLRequestJob::NotifyFailed(int rv) {
-  NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
-}
-
 }  // namespace fileapi