src/webkit/browser/blob/local_file_stream_reader.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 "webkit/browser/blob/local_file_stream_reader.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/files/file_util_proxy.h"
   9 #include "base/location.h"
  10 #include "base/logging.h"
  11 #include "base/platform_file.h"
  12 #include "base/task_runner.h"
  13 #include "net/base/file_stream.h"
  14 #include "net/base/io_buffer.h"
  15 #include "net/base/net_errors.h"
  16
  17 namespace webkit_blob {
  18
  19 namespace {
  20
  21 const int kOpenFlagsForRead = base::PLATFORM_FILE_OPEN |
  22                               base::PLATFORM_FILE_READ |
  23                               base::PLATFORM_FILE_ASYNC;
  24
  25 }  // namespace
  26
  27 FileStreamReader* FileStreamReader::CreateForLocalFile(
  28     base::TaskRunner* task_runner,
  29     const base::FilePath& file_path,
  30     int64 initial_offset,
  31     const base::Time& expected_modification_time) {
  32   return new LocalFileStreamReader(task_runner, file_path, initial_offset,
  33                                    expected_modification_time);
  34 }
  35
  36 LocalFileStreamReader::~LocalFileStreamReader() {
  37 }
  38
  39 int LocalFileStreamReader::Read(net::IOBuffer* buf, int buf_len,
  40                           const net::CompletionCallback& callback) {
  41   DCHECK(!has_pending_open_);
  42   if (stream_impl_)
  43     return stream_impl_->Read(buf, buf_len, callback);
  44   return Open(base::Bind(&LocalFileStreamReader::DidOpenForRead,
  45                          weak_factory_.GetWeakPtr(),
  46                          make_scoped_refptr(buf), buf_len, callback));
  47 }
  48
  49 int64 LocalFileStreamReader::GetLength(
  50     const net::Int64CompletionCallback& callback) {
  51   const bool posted = base::FileUtilProxy::GetFileInfo(
  52       task_runner_.get(),
  53       file_path_,
  54       base::Bind(&LocalFileStreamReader::DidGetFileInfoForGetLength,
  55                  weak_factory_.GetWeakPtr(),
  56                  callback));
  57   DCHECK(posted);
  58   return net::ERR_IO_PENDING;
  59 }
  60
  61 LocalFileStreamReader::LocalFileStreamReader(
  62     base::TaskRunner* task_runner,
  63     const base::FilePath& file_path,
  64     int64 initial_offset,
  65     const base::Time& expected_modification_time)
  66     : task_runner_(task_runner),
  67       file_path_(file_path),
  68       initial_offset_(initial_offset),
  69       expected_modification_time_(expected_modification_time),
  70       has_pending_open_(false),
  71       weak_factory_(this) {}
  72
  73 int LocalFileStreamReader::Open(const net::CompletionCallback& callback) {
  74   DCHECK(!has_pending_open_);
  75   DCHECK(!stream_impl_.get());
  76   has_pending_open_ = true;
  77
  78   // Call GetLength first to make it perform last-modified-time verification,
  79   // and then call DidVerifyForOpen for do the rest.
  80   return GetLength(base::Bind(&LocalFileStreamReader::DidVerifyForOpen,
  81                               weak_factory_.GetWeakPtr(), callback));
  82 }
  83
  84 void LocalFileStreamReader::DidVerifyForOpen(
  85     const net::CompletionCallback& callback,
  86     int64 get_length_result) {
  87   if (get_length_result < 0) {
  88     callback.Run(static_cast<int>(get_length_result));
  89     return;
  90   }
  91
  92   stream_impl_.reset(new net::FileStream(task_runner_));
  93   const int result = stream_impl_->Open(
  94       file_path_, kOpenFlagsForRead,
  95       base::Bind(&LocalFileStreamReader::DidOpenFileStream,
  96                  weak_factory_.GetWeakPtr(),
  97                  callback));
  98   if (result != net::ERR_IO_PENDING)
  99     callback.Run(result);
 100 }
 101
 102 void LocalFileStreamReader::DidOpenFileStream(
 103     const net::CompletionCallback& callback,
 104     int result) {
 105   if (result != net::OK) {
 106     callback.Run(result);
 107     return;
 108   }
 109   result = stream_impl_->Seek(
 110       net::FROM_BEGIN, initial_offset_,
 111       base::Bind(&LocalFileStreamReader::DidSeekFileStream,
 112                  weak_factory_.GetWeakPtr(),
 113                  callback));
 114   if (result != net::ERR_IO_PENDING) {
 115     callback.Run(result);
 116   }
 117 }
 118
 119 void LocalFileStreamReader::DidSeekFileStream(
 120     const net::CompletionCallback& callback,
 121     int64 seek_result) {
 122   if (seek_result < 0) {
 123     callback.Run(static_cast<int>(seek_result));
 124     return;
 125   }
 126   if (seek_result != initial_offset_) {
 127     callback.Run(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
 128     return;
 129   }
 130   callback.Run(net::OK);
 131 }
 132
 133 void LocalFileStreamReader::DidOpenForRead(
 134     net::IOBuffer* buf,
 135     int buf_len,
 136     const net::CompletionCallback& callback,
 137     int open_result) {
 138   DCHECK(has_pending_open_);
 139   has_pending_open_ = false;
 140   if (open_result != net::OK) {
 141     stream_impl_.reset();
 142     callback.Run(open_result);
 143     return;
 144   }
 145   DCHECK(stream_impl_.get());
 146   const int read_result = stream_impl_->Read(buf, buf_len, callback);
 147   if (read_result != net::ERR_IO_PENDING)
 148     callback.Run(read_result);
 149 }
 150
 151 void LocalFileStreamReader::DidGetFileInfoForGetLength(
 152     const net::Int64CompletionCallback& callback,
 153     base::File::Error error,
 154     const base::File::Info& file_info) {
 155   if (file_info.is_directory) {
 156     callback.Run(net::ERR_FILE_NOT_FOUND);
 157     return;
 158   }
 159   if (error != base::File::FILE_OK) {
 160     callback.Run(net::FileErrorToNetError(error));
 161     return;
 162   }
 163   if (!VerifySnapshotTime(expected_modification_time_, file_info)) {
 164     callback.Run(net::ERR_UPLOAD_FILE_CHANGED);
 165     return;
 166   }
 167   callback.Run(file_info.size);
 168 }
 169
 170 }  // namespace webkit_blob