storage/browser/fileapi/file_system_url_request_job.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "storage/browser/fileapi/file_system_url_request_job.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/files/file_path.h"
  12 #include "base/files/file_util_proxy.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/threading/thread_restrictions.h"
  15 #include "base/time/time.h"
  16 #include "build/build_config.h"
  17 #include "net/base/file_stream.h"
  18 #include "net/base/io_buffer.h"
  19 #include "net/base/mime_util.h"
  20 #include "net/base/net_errors.h"
  21 #include "net/base/net_util.h"
  22 #include "net/http/http_response_headers.h"
  23 #include "net/http/http_response_info.h"
  24 #include "net/http/http_util.h"
  25 #include "net/url_request/url_request.h"
  26 #include "storage/browser/fileapi/file_stream_reader.h"
  27 #include "storage/browser/fileapi/file_system_context.h"
  28 #include "storage/browser/fileapi/file_system_operation_runner.h"
  29 #include "storage/common/fileapi/file_system_util.h"
  30 #include "url/gurl.h"
  31
  32 using net::NetworkDelegate;
  33 using net::URLRequest;
  34 using net::URLRequestJob;
  35 using net::URLRequestStatus;
  36
  37 namespace storage {
  38
  39 static net::HttpResponseHeaders* CreateHttpResponseHeaders() {
  40   // HttpResponseHeaders expects its input string to be terminated by two NULs.
  41   static const char kStatus[] = "HTTP/1.1 200 OK\0";
  42   static const size_t kStatusLen = arraysize(kStatus);
  43
  44   net::HttpResponseHeaders* headers =
  45       new net::HttpResponseHeaders(std::string(kStatus, kStatusLen));
  46
  47   // Tell WebKit never to cache this content.
  48   std::string cache_control(net::HttpRequestHeaders::kCacheControl);
  49   cache_control.append(": no-cache");
  50   headers->AddHeader(cache_control);
  51
  52   return headers;
  53 }
  54
  55 FileSystemURLRequestJob::FileSystemURLRequestJob(
  56     URLRequest* request,
  57     NetworkDelegate* network_delegate,
  58     const std::string& storage_domain,
  59     FileSystemContext* file_system_context)
  60     : URLRequestJob(request, network_delegate),
  61       storage_domain_(storage_domain),
  62       file_system_context_(file_system_context),
  63       is_directory_(false),
  64       remaining_bytes_(0),
  65       weak_factory_(this) {
  66 }
  67
  68 FileSystemURLRequestJob::~FileSystemURLRequestJob() {}
  69
  70 void FileSystemURLRequestJob::Start() {
  71   base::MessageLoop::current()->PostTask(
  72       FROM_HERE,
  73       base::Bind(&FileSystemURLRequestJob::StartAsync,
  74                  weak_factory_.GetWeakPtr()));
  75 }
  76
  77 void FileSystemURLRequestJob::Kill() {
  78   reader_.reset();
  79   URLRequestJob::Kill();
  80   weak_factory_.InvalidateWeakPtrs();
  81 }
  82
  83 bool FileSystemURLRequestJob::ReadRawData(net::IOBuffer* dest,
  84                                           int dest_size,
  85                                           int* bytes_read) {
  86   DCHECK_NE(dest_size, 0);
  87   DCHECK(bytes_read);
  88   DCHECK_GE(remaining_bytes_, 0);
  89
  90   if (reader_.get() == NULL)
  91     return false;
  92
  93   if (remaining_bytes_ < dest_size)
  94     dest_size = static_cast<int>(remaining_bytes_);
  95
  96   if (!dest_size) {
  97     *bytes_read = 0;
  98     return true;
  99   }
 100
 101   const int rv = reader_->Read(dest, dest_size,
 102                                base::Bind(&FileSystemURLRequestJob::DidRead,
 103                                           weak_factory_.GetWeakPtr()));
 104   if (rv >= 0) {
 105     // Data is immediately available.
 106     *bytes_read = rv;
 107     remaining_bytes_ -= rv;
 108     DCHECK_GE(remaining_bytes_, 0);
 109     return true;
 110   }
 111   if (rv == net::ERR_IO_PENDING)
 112     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 113   else
 114     NotifyFailed(rv);
 115   return false;
 116 }
 117
 118 bool FileSystemURLRequestJob::GetMimeType(std::string* mime_type) const {
 119   DCHECK(request_);
 120   DCHECK(url_.is_valid());
 121   base::FilePath::StringType extension = url_.path().Extension();
 122   if (!extension.empty())
 123     extension = extension.substr(1);
 124   return net::GetWellKnownMimeTypeFromExtension(extension, mime_type);
 125 }
 126
 127 void FileSystemURLRequestJob::SetExtraRequestHeaders(
 128     const net::HttpRequestHeaders& headers) {
 129   std::string range_header;
 130   if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
 131     std::vector<net::HttpByteRange> ranges;
 132     if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
 133       if (ranges.size() == 1) {
 134         byte_range_ = ranges[0];
 135       } else {
 136         // We don't support multiple range requests in one single URL request.
 137         // TODO(adamk): decide whether we want to support multiple range
 138         // requests.
 139         NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
 140       }
 141     }
 142   }
 143 }
 144
 145 void FileSystemURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
 146   if (response_info_)
 147     *info = *response_info_;
 148 }
 149
 150 int FileSystemURLRequestJob::GetResponseCode() const {
 151   if (response_info_)
 152     return 200;
 153   return URLRequestJob::GetResponseCode();
 154 }
 155
 156 void FileSystemURLRequestJob::StartAsync() {
 157   if (!request_)
 158     return;
 159   DCHECK(!reader_.get());
 160   url_ = file_system_context_->CrackURL(request_->url());
 161   if (!url_.is_valid()) {
 162     file_system_context_->AttemptAutoMountForURLRequest(
 163         request_,
 164         storage_domain_,
 165         base::Bind(&FileSystemURLRequestJob::DidAttemptAutoMount,
 166                    weak_factory_.GetWeakPtr()));
 167     return;
 168   }
 169   if (!file_system_context_->CanServeURLRequest(url_)) {
 170     // In incognito mode the API is not usable and there should be no data.
 171     NotifyFailed(net::ERR_FILE_NOT_FOUND);
 172     return;
 173   }
 174   file_system_context_->operation_runner()->GetMetadata(
 175       url_,
 176       base::Bind(&FileSystemURLRequestJob::DidGetMetadata,
 177                  weak_factory_.GetWeakPtr()));
 178 }
 179
 180 void FileSystemURLRequestJob::DidAttemptAutoMount(base::File::Error result) {
 181   if (result >= 0 &&
 182       file_system_context_->CrackURL(request_->url()).is_valid()) {
 183     StartAsync();
 184   } else {
 185     NotifyFailed(net::ERR_FILE_NOT_FOUND);
 186   }
 187 }
 188
 189 void FileSystemURLRequestJob::DidGetMetadata(
 190     base::File::Error error_code,
 191     const base::File::Info& file_info) {
 192   if (error_code != base::File::FILE_OK) {
 193     NotifyFailed(error_code == base::File::FILE_ERROR_INVALID_URL ?
 194                  net::ERR_INVALID_URL : net::ERR_FILE_NOT_FOUND);
 195     return;
 196   }
 197
 198   // We may have been orphaned...
 199   if (!request_)
 200     return;
 201
 202   is_directory_ = file_info.is_directory;
 203
 204   if (!byte_range_.ComputeBounds(file_info.size)) {
 205     NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
 206     return;
 207   }
 208
 209   if (is_directory_) {
 210     NotifyHeadersComplete();
 211     return;
 212   }
 213
 214   remaining_bytes_ = byte_range_.last_byte_position() -
 215                      byte_range_.first_byte_position() + 1;
 216   DCHECK_GE(remaining_bytes_, 0);
 217
 218   DCHECK(!reader_.get());
 219   reader_ = file_system_context_->CreateFileStreamReader(
 220       url_, byte_range_.first_byte_position(), remaining_bytes_, base::Time());
 221
 222   set_expected_content_size(remaining_bytes_);
 223   response_info_.reset(new net::HttpResponseInfo());
 224   response_info_->headers = CreateHttpResponseHeaders();
 225   NotifyHeadersComplete();
 226 }
 227
 228 void FileSystemURLRequestJob::DidRead(int result) {
 229   if (result > 0)
 230     SetStatus(URLRequestStatus());  // Clear the IO_PENDING status
 231   else if (result == 0)
 232     NotifyDone(URLRequestStatus());
 233   else
 234     NotifyFailed(result);
 235
 236   remaining_bytes_ -= result;
 237   DCHECK_GE(remaining_bytes_, 0);
 238
 239   NotifyReadComplete(result);
 240 }
 241
 242 bool FileSystemURLRequestJob::IsRedirectResponse(GURL* location,
 243                                                  int* http_status_code) {
 244   if (is_directory_) {
 245     // This happens when we discovered the file is a directory, so needs a
 246     // slash at the end of the path.
 247     std::string new_path = request_->url().path();
 248     new_path.push_back('/');
 249     GURL::Replacements replacements;
 250     replacements.SetPathStr(new_path);
 251     *location = request_->url().ReplaceComponents(replacements);
 252     *http_status_code = 301;  // simulate a permanent redirect
 253     return true;
 254   }
 255
 256   return false;
 257 }
 258
 259 void FileSystemURLRequestJob::NotifyFailed(int rv) {
 260   NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 261 }
 262
 263 }  // namespace storage