net/base/file_stream.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 "net/base/file_stream.h"
   6
   7 #include "base/location.h"
   8 #include "base/message_loop/message_loop_proxy.h"
   9 #include "base/task_runner_util.h"
  10 #include "base/threading/thread_restrictions.h"
  11 #include "base/threading/worker_pool.h"
  12 #include "net/base/file_stream_context.h"
  13 #include "net/base/file_stream_net_log_parameters.h"
  14 #include "net/base/net_errors.h"
  15
  16 namespace net {
  17
  18 FileStream::FileStream(NetLog* net_log,
  19                        const scoped_refptr<base::TaskRunner>& task_runner)
  20       /* To allow never opened stream to be destroyed on any thread we set flags
  21          as if stream was opened asynchronously. */
  22     : open_flags_(base::PLATFORM_FILE_ASYNC),
  23       bound_net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_FILESTREAM)),
  24       context_(new Context(bound_net_log_, task_runner)) {
  25   bound_net_log_.BeginEvent(NetLog::TYPE_FILE_STREAM_ALIVE);
  26 }
  27
  28 FileStream::FileStream(NetLog* net_log)
  29       /* To allow never opened stream to be destroyed on any thread we set flags
  30          as if stream was opened asynchronously. */
  31     : open_flags_(base::PLATFORM_FILE_ASYNC),
  32       bound_net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_FILESTREAM)),
  33       context_(new Context(bound_net_log_,
  34                            base::WorkerPool::GetTaskRunner(true /* slow */))) {
  35   bound_net_log_.BeginEvent(NetLog::TYPE_FILE_STREAM_ALIVE);
  36 }
  37
  38 FileStream::FileStream(base::PlatformFile file,
  39                        int flags,
  40                        NetLog* net_log,
  41                        const scoped_refptr<base::TaskRunner>& task_runner)
  42     : open_flags_(flags),
  43       bound_net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_FILESTREAM)),
  44       context_(new Context(file, bound_net_log_, open_flags_, task_runner)) {
  45   bound_net_log_.BeginEvent(NetLog::TYPE_FILE_STREAM_ALIVE);
  46 }
  47
  48 FileStream::FileStream(base::PlatformFile file, int flags, NetLog* net_log)
  49     : open_flags_(flags),
  50       bound_net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_FILESTREAM)),
  51       context_(new Context(file,
  52                            bound_net_log_,
  53                            open_flags_,
  54                            base::WorkerPool::GetTaskRunner(true /* slow */))) {
  55   bound_net_log_.BeginEvent(NetLog::TYPE_FILE_STREAM_ALIVE);
  56 }
  57
  58 FileStream::~FileStream() {
  59   if (!is_async()) {
  60     base::ThreadRestrictions::AssertIOAllowed();
  61     context_->CloseSync();
  62     context_.reset();
  63   } else {
  64     context_.release()->Orphan();
  65   }
  66
  67   bound_net_log_.EndEvent(NetLog::TYPE_FILE_STREAM_ALIVE);
  68 }
  69
  70 int FileStream::Open(const base::FilePath& path, int open_flags,
  71                      const CompletionCallback& callback) {
  72   if (IsOpen()) {
  73     DLOG(FATAL) << "File is already open!";
  74     return ERR_UNEXPECTED;
  75   }
  76
  77   open_flags_ = open_flags;
  78   DCHECK(is_async());
  79   context_->OpenAsync(path, open_flags, callback);
  80   return ERR_IO_PENDING;
  81 }
  82
  83 int FileStream::OpenSync(const base::FilePath& path, int open_flags) {
  84   base::ThreadRestrictions::AssertIOAllowed();
  85
  86   if (IsOpen()) {
  87     DLOG(FATAL) << "File is already open!";
  88     return ERR_UNEXPECTED;
  89   }
  90
  91   open_flags_ = open_flags;
  92   DCHECK(!is_async());
  93   return context_->OpenSync(path, open_flags_);
  94 }
  95
  96 bool FileStream::IsOpen() const {
  97   return context_->file() != base::kInvalidPlatformFileValue;
  98 }
  99
 100 int FileStream::Seek(Whence whence,
 101                      int64 offset,
 102                      const Int64CompletionCallback& callback) {
 103   if (!IsOpen())
 104     return ERR_UNEXPECTED;
 105
 106   // Make sure we're async.
 107   DCHECK(is_async());
 108   context_->SeekAsync(whence, offset, callback);
 109   return ERR_IO_PENDING;
 110 }
 111
 112 int64 FileStream::SeekSync(Whence whence, int64 offset) {
 113   base::ThreadRestrictions::AssertIOAllowed();
 114
 115   if (!IsOpen())
 116     return ERR_UNEXPECTED;
 117
 118   // If we're in async, make sure we don't have a request in flight.
 119   DCHECK(!is_async() || !context_->async_in_progress());
 120   return context_->SeekSync(whence, offset);
 121 }
 122
 123 int64 FileStream::Available() {
 124   base::ThreadRestrictions::AssertIOAllowed();
 125
 126   if (!IsOpen())
 127     return ERR_UNEXPECTED;
 128
 129   int64 cur_pos = SeekSync(FROM_CURRENT, 0);
 130   if (cur_pos < 0)
 131     return cur_pos;
 132
 133   int64 size = context_->GetFileSize();
 134   if (size < 0)
 135     return size;
 136
 137   DCHECK_GE(size, cur_pos);
 138   return size - cur_pos;
 139 }
 140
 141 int FileStream::Read(IOBuffer* buf,
 142                      int buf_len,
 143                      const CompletionCallback& callback) {
 144   if (!IsOpen())
 145     return ERR_UNEXPECTED;
 146
 147   // read(..., 0) will return 0, which indicates end-of-file.
 148   DCHECK_GT(buf_len, 0);
 149   DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
 150   DCHECK(is_async());
 151
 152   return context_->ReadAsync(buf, buf_len, callback);
 153 }
 154
 155 int FileStream::ReadSync(char* buf, int buf_len) {
 156   base::ThreadRestrictions::AssertIOAllowed();
 157
 158   if (!IsOpen())
 159     return ERR_UNEXPECTED;
 160
 161   DCHECK(!is_async());
 162   // read(..., 0) will return 0, which indicates end-of-file.
 163   DCHECK_GT(buf_len, 0);
 164   DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
 165
 166   return context_->ReadSync(buf, buf_len);
 167 }
 168
 169 int FileStream::ReadUntilComplete(char *buf, int buf_len) {
 170   base::ThreadRestrictions::AssertIOAllowed();
 171
 172   int to_read = buf_len;
 173   int bytes_total = 0;
 174
 175   do {
 176     int bytes_read = ReadSync(buf, to_read);
 177     if (bytes_read <= 0) {
 178       if (bytes_total == 0)
 179         return bytes_read;
 180
 181       return bytes_total;
 182     }
 183
 184     bytes_total += bytes_read;
 185     buf += bytes_read;
 186     to_read -= bytes_read;
 187   } while (bytes_total < buf_len);
 188
 189   return bytes_total;
 190 }
 191
 192 int FileStream::Write(IOBuffer* buf,
 193                       int buf_len,
 194                       const CompletionCallback& callback) {
 195   if (!IsOpen())
 196     return ERR_UNEXPECTED;
 197
 198   DCHECK(is_async());
 199   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 200   // write(..., 0) will return 0, which indicates end-of-file.
 201   DCHECK_GT(buf_len, 0);
 202
 203   return context_->WriteAsync(buf, buf_len, callback);
 204 }
 205
 206 int FileStream::WriteSync(const char* buf, int buf_len) {
 207   base::ThreadRestrictions::AssertIOAllowed();
 208
 209   if (!IsOpen())
 210     return ERR_UNEXPECTED;
 211
 212   DCHECK(!is_async());
 213   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 214   // write(..., 0) will return 0, which indicates end-of-file.
 215   DCHECK_GT(buf_len, 0);
 216
 217   return context_->WriteSync(buf, buf_len);
 218 }
 219
 220 int64 FileStream::Truncate(int64 bytes) {
 221   base::ThreadRestrictions::AssertIOAllowed();
 222
 223   if (!IsOpen())
 224     return ERR_UNEXPECTED;
 225
 226   // We'd better be open for writing.
 227   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 228
 229   // Seek to the position to truncate from.
 230   int64 seek_position = SeekSync(FROM_BEGIN, bytes);
 231   if (seek_position != bytes)
 232     return ERR_UNEXPECTED;
 233
 234   // And truncate the file.
 235   return context_->Truncate(bytes);
 236 }
 237
 238 int FileStream::Flush(const CompletionCallback& callback) {
 239   if (!IsOpen())
 240     return ERR_UNEXPECTED;
 241
 242   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 243   // Make sure we're async.
 244   DCHECK(is_async());
 245
 246   context_->FlushAsync(callback);
 247   return ERR_IO_PENDING;
 248 }
 249
 250 int FileStream::FlushSync() {
 251   base::ThreadRestrictions::AssertIOAllowed();
 252
 253   if (!IsOpen())
 254     return ERR_UNEXPECTED;
 255
 256   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 257   return context_->FlushSync();
 258 }
 259
 260 void FileStream::EnableErrorStatistics() {
 261   context_->set_record_uma(true);
 262 }
 263
 264 void FileStream::SetBoundNetLogSource(const BoundNetLog& owner_bound_net_log) {
 265   if ((owner_bound_net_log.source().id == NetLog::Source::kInvalidId) &&
 266       (bound_net_log_.source().id == NetLog::Source::kInvalidId)) {
 267     // Both |BoundNetLog|s are invalid.
 268     return;
 269   }
 270
 271   // Should never connect to itself.
 272   DCHECK_NE(bound_net_log_.source().id, owner_bound_net_log.source().id);
 273
 274   bound_net_log_.AddEvent(NetLog::TYPE_FILE_STREAM_BOUND_TO_OWNER,
 275       owner_bound_net_log.source().ToEventParametersCallback());
 276
 277   owner_bound_net_log.AddEvent(NetLog::TYPE_FILE_STREAM_SOURCE,
 278       bound_net_log_.source().ToEventParametersCallback());
 279 }
 280
 281 base::PlatformFile FileStream::GetPlatformFileForTesting() {
 282   return context_->file();
 283 }
 284
 285 }  // namespace net