Add ThreadRestrictions to FileStream.

net/base/file_stream_win.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.
 
 #include "net/base/file_stream.h"
 
 #include <windows.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/threading/thread_restrictions.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 // Ensure that we can just use our Whence values directly.
 COMPILE_ASSERT(FROM_BEGIN == FILE_BEGIN, bad_whence_begin);
 COMPILE_ASSERT(FROM_CURRENT == FILE_CURRENT, bad_whence_current);
 COMPILE_ASSERT(FROM_END == FILE_END, bad_whence_end);
 
 static void SetOffset(OVERLAPPED* overlapped, const LARGE_INTEGER& offset) {
@@ skipping 168 matching lines @@
     DWORD error = GetLastError();
     LOG(WARNING) << "SetFilePointerEx failed: " << error;
     return MapErrorCode(error);
   }
   if (async_context_.get())
     SetOffset(async_context_->overlapped(), result);
   return result.QuadPart;
 }
 
 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;
 
   LARGE_INTEGER file_size;
   if (!GetFileSizeEx(file_, &file_size)) {
     DWORD error = GetLastError();
     LOG(WARNING) << "GetFileSizeEx failed: " << error;
     return MapErrorCode(error);
   }
 
   return file_size.QuadPart - cur_pos;
 }
 
 int FileStream::Read(
     char* buf, int buf_len, CompletionCallback* callback) {
   if (!IsOpen())
     return ERR_UNEXPECTED;
   DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
 
   OVERLAPPED* overlapped = NULL;
   if (async_context_.get()) {
+    DCHECK(callback);
     DCHECK(!async_context_->callback());
     overlapped = async_context_->overlapped();
+  } else {
+    DCHECK(!callback);
+    base::ThreadRestrictions::AssertIOAllowed();
   }
 
   int rv;
 
   DWORD bytes_read;
   if (!ReadFile(file_, buf, buf_len, &bytes_read, overlapped)) {
     DWORD error = GetLastError();
     if (async_context_.get() && error == ERROR_IO_PENDING) {
       async_context_->IOCompletionIsPending(callback);
       rv = ERR_IO_PENDING;
@@ skipping 34 matching lines @@
 }
 
 int FileStream::Write(
     const char* buf, int buf_len, CompletionCallback* callback) {
   if (!IsOpen())
     return ERR_UNEXPECTED;
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 
   OVERLAPPED* overlapped = NULL;
   if (async_context_.get()) {
+    DCHECK(callback);
     DCHECK(!async_context_->callback());
     overlapped = async_context_->overlapped();
+  } else {
+    DCHECK(!callback);
+    base::ThreadRestrictions::AssertIOAllowed();
   }
 
   int rv;
   DWORD bytes_written;
   if (!WriteFile(file_, buf, buf_len, &bytes_written, overlapped)) {
     DWORD error = GetLastError();
     if (async_context_.get() && error == ERROR_IO_PENDING) {
       async_context_->IOCompletionIsPending(callback);
       rv = ERR_IO_PENDING;
     } else {
       LOG(WARNING) << "WriteFile failed: " << error;
       rv = MapErrorCode(error);
     }
   } else if (overlapped) {
     async_context_->IOCompletionIsPending(callback);
     rv = ERR_IO_PENDING;
   } else {
     rv = static_cast<int>(bytes_written);
   }
   return rv;
 }
 
 int FileStream::Flush() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
   if (FlushFileBuffers(file_)) {
     return OK;
   }
 
   int rv;
   DWORD error = GetLastError();
   rv = MapErrorCode(error);
   return rv;
 }
 
 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.
   BOOL result = SetEndOfFile(file_);
   if (!result) {
     DWORD error = GetLastError();
     LOG(WARNING) << "SetEndOfFile failed: " << error;
     return MapErrorCode(error);
   }
 
   // Success.
   return seek_position;
 }
 
 }  // namespace net