Add ThreadRestrictions to FileStream.

net/base/file_stream_posix.cc

 // Copyright (c) 2010 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.
 
 // For 64-bit file access (off_t = off64_t, lseek64, etc).
 #define _FILE_OFFSET_BITS 64
 
 #include "net/base/file_stream.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 
 // We cast back and forth, so make sure it's the size we're expecting.
 COMPILE_ASSERT(sizeof(int64) == sizeof(off_t), off_t_64_bit);
 
 // Make sure our Whence mappings match the system headers.
 COMPILE_ASSERT(net::FROM_BEGIN   == SEEK_SET &&
                net::FROM_CURRENT == SEEK_CUR &&
@@ skipping 11 matching lines @@
       return ERR_ACCESS_DENIED;
     default:
       LOG(WARNING) << "Unknown error " << err << " mapped to net::ERR_FAILED";
       return ERR_FAILED;
   }
 }
 
 // ReadFile() is a simple wrapper around read() that handles EINTR signals and
 // calls MapErrorCode() to map errno to net error codes.
 int ReadFile(base::PlatformFile file, char* buf, int buf_len) {
+  base::ThreadRestrictions::AssertIOAllowed();
   // read(..., 0) returns 0 to indicate end-of-file.
 
   // Loop in the case of getting interrupted by a signal.
   ssize_t res = HANDLE_EINTR(read(file, buf, static_cast<size_t>(buf_len)));
   if (res == static_cast<ssize_t>(-1))
     return MapErrorCode(errno);
   return static_cast<int>(res);
 }
 
 // WriteFile() is a simple wrapper around write() that handles EINTR signals and
 // calls MapErrorCode() to map errno to net error codes.  It tries to write to
 // completion.
 int WriteFile(base::PlatformFile file, const char* buf, int buf_len) {
+  base::ThreadRestrictions::AssertIOAllowed();
   ssize_t res = HANDLE_EINTR(write(file, buf, buf_len));
   if (res == -1)
     return MapErrorCode(errno);
   return res;
 }
 
 // FlushFile() is a simple wrapper around fsync() that handles EINTR signals and
 // calls MapErrorCode() to map errno to net error codes.  It tries to flush to
 // completion.
 int FlushFile(base::PlatformFile file) {
+  base::ThreadRestrictions::AssertIOAllowed();
   ssize_t res = HANDLE_EINTR(fsync(file));
   if (res == -1)
     return MapErrorCode(errno);
   return res;
 }
 
 // BackgroundReadTask is a simple task that reads a file and then runs
 // |callback|.  AsyncContext will post this task to the WorkerPool.
 class BackgroundReadTask : public Task {
  public:
@@ skipping 267 matching lines @@
   }
 
   return OK;
 }
 
 bool FileStream::IsOpen() const {
   return file_ != base::kInvalidPlatformFileValue;
 }
 
 int64 FileStream::Seek(Whence whence, int64 offset) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   // If we're in async, make sure we don't have a request in flight.
   DCHECK(!async_context_.get() || !async_context_->callback());
 
   off_t res = lseek(file_, static_cast<off_t>(offset),
                     static_cast<int>(whence));
   if (res == static_cast<off_t>(-1))
     return MapErrorCode(errno);
 
   return res;
 }
 
 int64 FileStream::Available() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   int64 cur_pos = Seek(FROM_CURRENT, 0);
   if (cur_pos < 0)
     return cur_pos;
 
   struct stat info;
   if (fstat(file_, &info) != 0)
     return MapErrorCode(errno);
@@ skipping 41 matching lines @@
     buf += bytes_read;
     to_read -= bytes_read;
   } while (bytes_total < buf_len);
 
   return bytes_total;
 }
 
 int FileStream::Write(
     const char* buf, int buf_len, CompletionCallback* callback) {
   // write(..., 0) will return 0, which indicates end-of-file.
-  DCHECK(buf_len > 0);
+  DCHECK_GT(buf_len, 0);
 
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   if (async_context_.get()) {
     DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
     // If we're in async, make sure we don't have a request in flight.
     DCHECK(!async_context_->callback());
     async_context_->InitiateAsyncWrite(file_, buf, buf_len, callback);
     return ERR_IO_PENDING;
   } else {
     return WriteFile(file_, buf, buf_len);
   }
 }
 
 int64 FileStream::Truncate(int64 bytes) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   // We better be open for reading.
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 
   // Seek to the position to truncate from.
   int64 seek_position = Seek(FROM_BEGIN, bytes);
   if (seek_position != bytes)
     return ERR_UNEXPECTED;
 
   // And truncate the file.
   int result = ftruncate(file_, bytes);
   return result == 0 ? seek_position : MapErrorCode(errno);
 }
 
 int FileStream::Flush() {
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   return FlushFile(file_);
 }
 
 }  // namespace net