net/disk_cache/blockfile/file_win.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/disk_cache/blockfile/file.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "net/base/net_errors.h"
  11 #include "net/disk_cache/disk_cache.h"
  12
  13 namespace {
  14
  15 // Structure used for asynchronous operations.
  16 struct MyOverlapped {
  17   MyOverlapped(disk_cache::File* file, size_t offset,
  18                disk_cache::FileIOCallback* callback);
  19   ~MyOverlapped() {}
  20   OVERLAPPED* overlapped() {
  21     return &context_.overlapped;
  22   }
  23
  24   base::MessageLoopForIO::IOContext context_;
  25   scoped_refptr<disk_cache::File> file_;
  26   disk_cache::FileIOCallback* callback_;
  27 };
  28
  29 COMPILE_ASSERT(!offsetof(MyOverlapped, context_), starts_with_overlapped);
  30
  31 // Helper class to handle the IO completion notifications from the message loop.
  32 class CompletionHandler : public base::MessageLoopForIO::IOHandler {
  33   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
  34                              DWORD actual_bytes,
  35                              DWORD error);
  36 };
  37
  38 static base::LazyInstance<CompletionHandler> g_completion_handler =
  39     LAZY_INSTANCE_INITIALIZER;
  40
  41 void CompletionHandler::OnIOCompleted(
  42     base::MessageLoopForIO::IOContext* context,
  43     DWORD actual_bytes,
  44     DWORD error) {
  45   MyOverlapped* data = reinterpret_cast<MyOverlapped*>(context);
  46
  47   if (error) {
  48     DCHECK(!actual_bytes);
  49     actual_bytes = static_cast<DWORD>(net::ERR_CACHE_READ_FAILURE);
  50     NOTREACHED();
  51   }
  52
  53   if (data->callback_)
  54     data->callback_->OnFileIOComplete(static_cast<int>(actual_bytes));
  55
  56   delete data;
  57 }
  58
  59 MyOverlapped::MyOverlapped(disk_cache::File* file, size_t offset,
  60                            disk_cache::FileIOCallback* callback) {
  61   memset(this, 0, sizeof(*this));
  62   context_.handler = g_completion_handler.Pointer();
  63   context_.overlapped.Offset = static_cast<DWORD>(offset);
  64   file_ = file;
  65   callback_ = callback;
  66 }
  67
  68 }  // namespace
  69
  70 namespace disk_cache {
  71
  72 File::File(base::File file)
  73     : init_(true),
  74       mixed_(true),
  75       sync_base_file_(file.Pass()) {
  76 }
  77
  78 bool File::Init(const base::FilePath& name) {
  79   DCHECK(!init_);
  80   if (init_)
  81     return false;
  82
  83   DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
  84   DWORD access = GENERIC_READ | GENERIC_WRITE | DELETE;
  85   base_file_ =
  86       base::File(CreateFile(name.value().c_str(), access, sharing, NULL,
  87                             OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL));
  88
  89   if (!base_file_.IsValid())
  90     return false;
  91
  92   base::MessageLoopForIO::current()->RegisterIOHandler(
  93       base_file_.GetPlatformFile(), g_completion_handler.Pointer());
  94
  95   init_ = true;
  96   sync_base_file_  =
  97     base::File(CreateFile(name.value().c_str(), access, sharing, NULL,
  98                           OPEN_EXISTING, 0, NULL));
  99
 100   if (!sync_base_file_.IsValid())
 101     return false;
 102
 103   return true;
 104 }
 105
 106 bool File::IsValid() const {
 107   if (!init_)
 108     return false;
 109   return base_file_.IsValid() || sync_base_file_.IsValid();
 110 }
 111
 112 bool File::Read(void* buffer, size_t buffer_len, size_t offset) {
 113   DCHECK(init_);
 114   if (buffer_len > ULONG_MAX || offset > LONG_MAX)
 115     return false;
 116
 117   int ret = sync_base_file_.Read(offset, static_cast<char*>(buffer),
 118                                  buffer_len);
 119   return static_cast<int>(buffer_len) == ret;
 120 }
 121
 122 bool File::Write(const void* buffer, size_t buffer_len, size_t offset) {
 123   DCHECK(init_);
 124   if (buffer_len > ULONG_MAX || offset > ULONG_MAX)
 125     return false;
 126
 127   int ret = sync_base_file_.Write(offset, static_cast<const char*>(buffer),
 128                                  buffer_len);
 129   return static_cast<int>(buffer_len) == ret;
 130 }
 131
 132 // We have to increase the ref counter of the file before performing the IO to
 133 // prevent the completion to happen with an invalid handle (if the file is
 134 // closed while the IO is in flight).
 135 bool File::Read(void* buffer, size_t buffer_len, size_t offset,
 136                 FileIOCallback* callback, bool* completed) {
 137   DCHECK(init_);
 138   if (!callback) {
 139     if (completed)
 140       *completed = true;
 141     return Read(buffer, buffer_len, offset);
 142   }
 143
 144   if (buffer_len > ULONG_MAX || offset > ULONG_MAX)
 145     return false;
 146
 147   MyOverlapped* data = new MyOverlapped(this, offset, callback);
 148   DWORD size = static_cast<DWORD>(buffer_len);
 149
 150   DWORD actual;
 151   if (!ReadFile(base_file_.GetPlatformFile(), buffer, size, &actual,
 152                 data->overlapped())) {
 153     *completed = false;
 154     if (GetLastError() == ERROR_IO_PENDING)
 155       return true;
 156     delete data;
 157     return false;
 158   }
 159
 160   // The operation completed already. We'll be called back anyway.
 161   *completed = (actual == size);
 162   DCHECK_EQ(size, actual);
 163   data->callback_ = NULL;
 164   data->file_ = NULL;  // There is no reason to hold on to this anymore.
 165   return *completed;
 166 }
 167
 168 bool File::Write(const void* buffer, size_t buffer_len, size_t offset,
 169                  FileIOCallback* callback, bool* completed) {
 170   DCHECK(init_);
 171   if (!callback) {
 172     if (completed)
 173       *completed = true;
 174     return Write(buffer, buffer_len, offset);
 175   }
 176
 177   return AsyncWrite(buffer, buffer_len, offset, callback, completed);
 178 }
 179
 180 File::~File() {
 181 }
 182
 183 base::PlatformFile File::platform_file() const {
 184   DCHECK(init_);
 185   return base_file_.IsValid() ? base_file_.GetPlatformFile() :
 186                                 sync_base_file_.GetPlatformFile();
 187 }
 188
 189 bool File::AsyncWrite(const void* buffer, size_t buffer_len, size_t offset,
 190                       FileIOCallback* callback, bool* completed) {
 191   DCHECK(init_);
 192   DCHECK(callback);
 193   DCHECK(completed);
 194   if (buffer_len > ULONG_MAX || offset > ULONG_MAX)
 195     return false;
 196
 197   MyOverlapped* data = new MyOverlapped(this, offset, callback);
 198   DWORD size = static_cast<DWORD>(buffer_len);
 199
 200   DWORD actual;
 201   if (!WriteFile(base_file_.GetPlatformFile(), buffer, size, &actual,
 202                  data->overlapped())) {
 203     *completed = false;
 204     if (GetLastError() == ERROR_IO_PENDING)
 205       return true;
 206     delete data;
 207     return false;
 208   }
 209
 210   // The operation completed already. We'll be called back anyway.
 211   *completed = (actual == size);
 212   DCHECK_EQ(size, actual);
 213   data->callback_ = NULL;
 214   data->file_ = NULL;  // There is no reason to hold on to this anymore.
 215   return *completed;
 216 }
 217
 218 bool File::SetLength(size_t length) {
 219   DCHECK(init_);
 220   if (length > ULONG_MAX)
 221     return false;
 222
 223   DWORD size = static_cast<DWORD>(length);
 224   HANDLE file = platform_file();
 225   if (INVALID_SET_FILE_POINTER == SetFilePointer(file, size, NULL, FILE_BEGIN))
 226     return false;
 227
 228   return TRUE == SetEndOfFile(file);
 229 }
 230
 231 size_t File::GetLength() {
 232   DCHECK(init_);
 233   LARGE_INTEGER size;
 234   HANDLE file = platform_file();
 235   if (!GetFileSizeEx(file, &size))
 236     return 0;
 237   if (size.HighPart)
 238     return ULONG_MAX;
 239
 240   return static_cast<size_t>(size.LowPart);
 241 }
 242
 243 // Static.
 244 void File::WaitForPendingIO(int* num_pending_io) {
 245   while (*num_pending_io) {
 246     // Asynchronous IO operations may be in flight and the completion may end
 247     // up calling us back so let's wait for them.
 248     base::MessageLoopForIO::IOHandler* handler = g_completion_handler.Pointer();
 249     base::MessageLoopForIO::current()->WaitForIOCompletion(100, handler);
 250   }
 251 }
 252
 253 // Static.
 254 void File::DropPendingIO() {
 255 }
 256
 257 }  // namespace disk_cache