chrome/browser/chromeos/drive/drive_url_request_job.cc

   1 // Copyright 2013 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 "chrome/browser/chromeos/drive/drive_url_request_job.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/logging.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "chrome/browser/browser_process.h"
  14 #include "chrome/browser/chromeos/drive/file_system_util.h"
  15 #include "chrome/browser/extensions/api/file_handlers/mime_util.h"
  16 #include "chrome/browser/profiles/profile_manager.h"
  17 #include "chrome/common/url_constants.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/browser/storage_partition.h"
  20 #include "net/base/net_errors.h"
  21 #include "net/http/http_byte_range.h"
  22 #include "net/http/http_request_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 "net/url_request/url_request_status.h"
  27 #include "storage/browser/fileapi/file_system_backend.h"
  28 #include "storage/browser/fileapi/file_system_context.h"
  29 #include "storage/browser/fileapi/file_system_operation_runner.h"
  30
  31 using content::BrowserThread;
  32
  33 namespace drive {
  34 namespace {
  35
  36 const char kMimeTypeForRFC822[] = "message/rfc822";
  37 const char kMimeTypeForMHTML[] = "multipart/related";
  38
  39 // Check if the |url| points a valid location or not.
  40 bool IsValidURL(const storage::FileSystemURL& url) {
  41   switch (url.type()) {
  42     case storage::kFileSystemTypeDrive: {
  43       const base::FilePath my_drive_path = util::GetDriveMyDriveRootPath();
  44       const base::FilePath drive_other_path =
  45           util::GetDriveGrandRootPath().Append(util::kDriveOtherDirName);
  46       const base::FilePath url_drive_path =
  47           util::ExtractDrivePathFromFileSystemUrl(url);
  48       return my_drive_path == url_drive_path ||
  49              my_drive_path.IsParent(url_drive_path) ||
  50              drive_other_path.IsParent(url_drive_path);
  51     }
  52     default:
  53       return false;
  54   }
  55 }
  56
  57 // Helper for obtaining FileSystemContext, FileSystemURL, and mime type on the
  58 // UI thread.
  59 class URLHelper {
  60  public:
  61   // The scoped pointer to control lifetime of the instance itself. The pointer
  62   // is passed to callback functions and binds the lifetime of the instance to
  63   // the callback's lifetime.
  64   typedef scoped_ptr<URLHelper> Lifetime;
  65
  66   URLHelper(void* profile_id,
  67             const GURL& url,
  68             const DriveURLRequestJob::HelperCallback& callback)
  69       : profile_id_(profile_id), url_(url), callback_(callback) {
  70     DCHECK_CURRENTLY_ON(BrowserThread::IO);
  71     Lifetime lifetime(this);
  72     BrowserThread::PostTask(BrowserThread::UI,
  73                             FROM_HERE,
  74                             base::Bind(&URLHelper::RunOnUIThread,
  75                                        base::Unretained(this),
  76                                        base::Passed(&lifetime)));
  77   }
  78
  79  private:
  80   void RunOnUIThread(Lifetime lifetime) {
  81     DCHECK_CURRENTLY_ON(BrowserThread::UI);
  82     Profile* const profile = reinterpret_cast<Profile*>(profile_id_);
  83     if (!g_browser_process->profile_manager()->IsValidProfile(profile)) {
  84       ReplyResult(net::ERR_FAILED);
  85       return;
  86     }
  87     content::StoragePartition* const storage =
  88         content::BrowserContext::GetStoragePartitionForSite(profile, url_);
  89     DCHECK(storage);
  90
  91     scoped_refptr<storage::FileSystemContext> context =
  92         storage->GetFileSystemContext();
  93     DCHECK(context.get());
  94
  95     // Obtain the absolute path in the file system.
  96     base::FilePath path = drive::util::GetDriveMountPointPath(profile);
  97     drive::util::GetDriveGrandRootPath().AppendRelativePath(
  98         util::DriveURLToFilePath(url_), &path);
  99
 100     storage::ExternalFileSystemBackend* const backend =
 101         context->external_backend();
 102     DCHECK(backend);
 103
 104     // Obtain the virtual path.
 105     base::FilePath virtual_path;
 106     if (!backend->GetVirtualPath(path, &virtual_path)) {
 107       ReplyResult(net::ERR_FILE_NOT_FOUND);
 108       return;
 109     }
 110
 111     // Obtain the file system URL.
 112     // TODO(hirono): After removing MHTML support, stop to use the special
 113     // drive: scheme and use filesystem: URL directly.  crbug.com/415455
 114     file_system_url_ = context->CreateCrackedFileSystemURL(
 115         GURL(std::string(chrome::kDriveScheme) + ":"),
 116         storage::kFileSystemTypeExternal,
 117         virtual_path);
 118     if (!IsValidURL(file_system_url_)) {
 119       ReplyResult(net::ERR_INVALID_URL);
 120       return;
 121     }
 122
 123     file_system_context_ = context;
 124
 125     extensions::app_file_handler_util::GetMimeTypeForLocalPath(
 126         profile,
 127         file_system_url_.path(),
 128         base::Bind(&URLHelper::OnGotMimeTypeOnUIThread,
 129                    base::Unretained(this),
 130                    base::Passed(&lifetime)));
 131   }
 132
 133   void OnGotMimeTypeOnUIThread(Lifetime lifetime,
 134                                const std::string& mime_type) {
 135     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 136     mime_type_ = mime_type;
 137
 138     if (mime_type_ == kMimeTypeForRFC822)
 139       mime_type_ = kMimeTypeForMHTML;
 140
 141     ReplyResult(net::OK);
 142   }
 143
 144   void ReplyResult(net::Error error) {
 145     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 146
 147     BrowserThread::PostTask(BrowserThread::IO,
 148                             FROM_HERE,
 149                             base::Bind(callback_,
 150                                        error,
 151                                        file_system_context_,
 152                                        file_system_url_,
 153                                        mime_type_));
 154   }
 155
 156   void* const profile_id_;
 157   const GURL url_;
 158   const DriveURLRequestJob::HelperCallback callback_;
 159   scoped_refptr<storage::FileSystemContext> file_system_context_;
 160   storage::FileSystemURL file_system_url_;
 161   std::string mime_type_;
 162
 163   DISALLOW_COPY_AND_ASSIGN(URLHelper);
 164 };
 165
 166 }  // namespace
 167
 168 DriveURLRequestJob::DriveURLRequestJob(void* profile_id,
 169                                        net::URLRequest* request,
 170                                        net::NetworkDelegate* network_delegate)
 171     : net::URLRequestJob(request, network_delegate),
 172       profile_id_(profile_id),
 173       remaining_bytes_(0),
 174       weak_ptr_factory_(this) {
 175 }
 176
 177 void DriveURLRequestJob::SetExtraRequestHeaders(
 178     const net::HttpRequestHeaders& headers) {
 179   std::string range_header;
 180   if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
 181     // Note: We only support single range requests.
 182     std::vector<net::HttpByteRange> ranges;
 183     if (net::HttpUtil::ParseRangeHeader(range_header, &ranges) &&
 184         ranges.size() == 1) {
 185       byte_range_ = ranges[0];
 186     } else {
 187       // Failed to parse Range: header, so notify the error.
 188       NotifyDone(
 189           net::URLRequestStatus(net::URLRequestStatus::FAILED,
 190                                 net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
 191     }
 192   }
 193 }
 194
 195 void DriveURLRequestJob::Start() {
 196   DVLOG(1) << "Starting request";
 197   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 198   DCHECK(!stream_reader_);
 199
 200   // We only support GET request.
 201   if (request()->method() != "GET") {
 202     LOG(WARNING) << "Failed to start request: "
 203                  << request()->method() << " method is not supported";
 204     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
 205                                            net::ERR_METHOD_NOT_SUPPORTED));
 206     return;
 207   }
 208
 209   // Check if the scheme is correct.
 210   if (!request()->url().SchemeIs(chrome::kDriveScheme)) {
 211     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
 212                                            net::ERR_INVALID_URL));
 213     return;
 214   }
 215
 216   // Owned by itself.
 217   new URLHelper(profile_id_,
 218                 request()->url(),
 219                 base::Bind(&DriveURLRequestJob::OnHelperResultObtained,
 220                            weak_ptr_factory_.GetWeakPtr()));
 221 }
 222
 223 void DriveURLRequestJob::OnHelperResultObtained(
 224     net::Error error,
 225     const scoped_refptr<storage::FileSystemContext>& file_system_context,
 226     const storage::FileSystemURL& file_system_url,
 227     const std::string& mime_type) {
 228   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 229
 230   if (error != net::OK) {
 231     NotifyStartError(
 232         net::URLRequestStatus(net::URLRequestStatus::FAILED, error));
 233     return;
 234   }
 235
 236   DCHECK(file_system_context.get());
 237   file_system_context_ = file_system_context;
 238   file_system_url_ = file_system_url;
 239   mime_type_ = mime_type;
 240
 241   // Check if the entry has a redirect URL.
 242   file_system_context_->external_backend()->GetRedirectURLForContents(
 243       file_system_url_,
 244       base::Bind(&DriveURLRequestJob::OnRedirectURLObtained,
 245                  weak_ptr_factory_.GetWeakPtr()));
 246 }
 247
 248 void DriveURLRequestJob::OnRedirectURLObtained(const GURL& redirect_url) {
 249   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 250   redirect_url_ = redirect_url;
 251   if (!redirect_url_.is_empty()) {
 252     NotifyHeadersComplete();
 253     return;
 254   }
 255
 256   // Obtain file system context.
 257   file_system_context_->operation_runner()->GetMetadata(
 258       file_system_url_,
 259       base::Bind(&DriveURLRequestJob::OnFileInfoObtained,
 260                  weak_ptr_factory_.GetWeakPtr()));
 261 }
 262
 263 void DriveURLRequestJob::OnFileInfoObtained(base::File::Error result,
 264                                             const base::File::Info& file_info) {
 265   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 266
 267   if (result == base::File::FILE_ERROR_NOT_FOUND) {
 268     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
 269                                            net::ERR_FILE_NOT_FOUND));
 270     return;
 271   }
 272
 273   if (result != base::File::FILE_OK || file_info.is_directory ||
 274       file_info.size < 0) {
 275     NotifyStartError(
 276         net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
 277     return;
 278   }
 279
 280   // Compute content size.
 281   if (!byte_range_.ComputeBounds(file_info.size)) {
 282     NotifyStartError(net::URLRequestStatus(
 283         net::URLRequestStatus::FAILED, net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
 284     return;
 285   }
 286   const int64 offset = byte_range_.first_byte_position();
 287   const int64 size =
 288       byte_range_.last_byte_position() + 1 - byte_range_.first_byte_position();
 289   set_expected_content_size(size);
 290   remaining_bytes_ = size;
 291
 292   // Create file stream reader.
 293   stream_reader_ = file_system_context_->CreateFileStreamReader(
 294       file_system_url_, offset, size, base::Time());
 295   if (!stream_reader_) {
 296     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
 297                                            net::ERR_FILE_NOT_FOUND));
 298     return;
 299   }
 300
 301   NotifyHeadersComplete();
 302 }
 303
 304 void DriveURLRequestJob::Kill() {
 305   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 306
 307   stream_reader_.reset();
 308   file_system_context_ = NULL;
 309   net::URLRequestJob::Kill();
 310   weak_ptr_factory_.InvalidateWeakPtrs();
 311 }
 312
 313 bool DriveURLRequestJob::GetMimeType(std::string* mime_type) const {
 314   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 315   mime_type->assign(mime_type_);
 316   return !mime_type->empty();
 317 }
 318
 319 bool DriveURLRequestJob::IsRedirectResponse(
 320     GURL* location, int* http_status_code) {
 321   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 322   if (redirect_url_.is_empty())
 323     return false;
 324
 325   // Redirect a hosted document.
 326   *location = redirect_url_;
 327   const int kHttpFound = 302;
 328   *http_status_code = kHttpFound;
 329   return true;
 330 }
 331
 332 bool DriveURLRequestJob::ReadRawData(
 333     net::IOBuffer* buf, int buf_size, int* bytes_read) {
 334   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 335   DCHECK(stream_reader_);
 336
 337   if (remaining_bytes_ == 0) {
 338     *bytes_read = 0;
 339     return true;
 340   }
 341
 342   const int result =
 343       stream_reader_->Read(buf,
 344                            std::min<int64>(buf_size, remaining_bytes_),
 345                            base::Bind(&DriveURLRequestJob::OnReadCompleted,
 346                                       weak_ptr_factory_.GetWeakPtr()));
 347
 348   if (result == net::ERR_IO_PENDING) {
 349     // The data is not yet available.
 350     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
 351     return false;
 352   }
 353   if (result < 0) {
 354     // An error occurs.
 355     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
 356     return false;
 357   }
 358
 359   // Reading has been finished immediately.
 360   *bytes_read = result;
 361   remaining_bytes_ -= result;
 362   return true;
 363 }
 364
 365 DriveURLRequestJob::~DriveURLRequestJob() {
 366 }
 367
 368 void DriveURLRequestJob::OnReadCompleted(int read_result) {
 369   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 370
 371   if (read_result < 0) {
 372     DCHECK_NE(read_result, net::ERR_IO_PENDING);
 373     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
 374                                      read_result));
 375   }
 376
 377   remaining_bytes_ -= read_result;
 378   SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status.
 379   NotifyReadComplete(read_result);
 380 }
 381
 382 }  // namespace drive