Index: net/disk_cache/in_flight_io.cc |
=================================================================== |
--- net/disk_cache/in_flight_io.cc (revision 51874) |
+++ net/disk_cache/in_flight_io.cc (working copy) |
@@ -1,218 +1,31 @@ |
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. |
+// Copyright (c) 2006-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/disk_cache/file.h" |
+#include "net/disk_cache/in_flight_io.h" |
-#include <fcntl.h> |
- |
-#include <set> |
- |
#include "base/logging.h" |
-#include "base/message_loop.h" |
-#include "base/singleton.h" |
-#include "base/waitable_event.h" |
-#include "base/worker_pool.h" |
-#include "net/disk_cache/disk_cache.h" |
-namespace { |
+namespace disk_cache { |
-class InFlightIO; |
- |
-// This class represents a single asynchronous IO operation while it is being |
-// bounced between threads. |
-class BackgroundIO : public base::RefCountedThreadSafe<BackgroundIO> { |
- public: |
- // Other than the actual parameters for the IO operation (including the |
- // |callback| that must be notified at the end), we need the controller that |
- // is keeping track of all operations. When done, we notify the controller |
- // (we do NOT invoke the callback), in the worker thead that completed the |
- // operation. |
- BackgroundIO(disk_cache::File* file, const void* buf, size_t buf_len, |
- size_t offset, disk_cache::FileIOCallback* callback, |
- InFlightIO* controller) |
- : io_completed_(true, false), callback_(callback), file_(file), buf_(buf), |
- buf_len_(buf_len), offset_(offset), controller_(controller), |
- bytes_(0) {} |
- |
- // Read and Write are the operations that can be performed asynchronously. |
- // The actual parameters for the operation are setup in the constructor of |
- // the object, with the exception of |delete_buffer|, that allows a write |
- // without a callback. Both methods should be called from a worker thread, by |
- // posting a task to the WorkerPool (they are RunnableMethods). When finished, |
- // controller->OnIOComplete() is called. |
- void Read(); |
- void Write(bool delete_buffer); |
- |
- // This method signals the controller that this operation is finished, in the |
- // original thread (presumably the IO-Thread). In practice, this is a |
- // RunableMethod that allows cancellation. |
- void OnIOSignalled(); |
- |
- // Allows the cancellation of the task to notify the controller (step number 7 |
- // in the diagram below). In practice, if the controller waits for the |
- // operation to finish it doesn't have to wait for the final task to be |
- // processed by the message loop so calling this method prevents its delivery. |
- // Note that this method is not intended to cancel the actual IO operation or |
- // to prevent the first notification to take place (OnIOComplete). |
- void Cancel(); |
- |
- // Retrieves the number of bytes transfered. |
- int Result(); |
- |
- base::WaitableEvent* io_completed() { |
- return &io_completed_; |
- } |
- |
- disk_cache::FileIOCallback* callback() { |
- return callback_; |
- } |
- |
- disk_cache::File* file() { |
- return file_; |
- } |
- |
- private: |
- friend class base::RefCountedThreadSafe<BackgroundIO>; |
- ~BackgroundIO() {} |
- |
- // An event to signal when the operation completes, and the user callback that |
- // has to be invoked. These members are accessed directly by the controller. |
- base::WaitableEvent io_completed_; |
- disk_cache::FileIOCallback* callback_; |
- |
- disk_cache::File* file_; |
- const void* buf_; |
- size_t buf_len_; |
- size_t offset_; |
- InFlightIO* controller_; // The controller that tracks all operations. |
- int bytes_; // Final operation result. |
- |
- DISALLOW_COPY_AND_ASSIGN(BackgroundIO); |
-}; |
- |
-// This class keeps track of every asynchronous IO operation. A single instance |
-// of this class is meant to be used to start an asynchronous operation (using |
-// PostRead/PostWrite). This class will post the operation to a worker thread, |
-// hanlde the notification when the operation finishes and perform the callback |
-// on the same thread that was used to start the operation. |
-// |
-// The regular sequence of calls is: |
-// Thread_1 Worker_thread |
-// 1. InFlightIO::PostRead() |
-// 2. -> PostTask -> |
-// 3. BackgroundIO::Read() |
-// 4. IO operation completes |
-// 5. InFlightIO::OnIOComplete() |
-// 6. <- PostTask <- |
-// 7. BackgroundIO::OnIOSignalled() |
-// 8. InFlightIO::InvokeCallback() |
-// 9. invoke callback |
-// |
-// Shutdown is a special case that is handled though WaitForPendingIO() instead |
-// of just waiting for step 7. |
-class InFlightIO { |
- public: |
- InFlightIO() : callback_thread_(MessageLoop::current()) {} |
- ~InFlightIO() {} |
- |
- // These methods start an asynchronous operation. The arguments have the same |
- // semantics of the File asynchronous operations, with the exception that the |
- // operation never finishes synchronously. |
- void PostRead(disk_cache::File* file, void* buf, size_t buf_len, |
- size_t offset, disk_cache::FileIOCallback* callback); |
- void PostWrite(disk_cache::File* file, const void* buf, size_t buf_len, |
- size_t offset, disk_cache::FileIOCallback* callback, |
- bool delete_buffer); |
- |
- // Blocks the current thread until all IO operations tracked by this object |
- // complete. |
- void WaitForPendingIO(); |
- |
- // Called on a worker thread when |operation| completes. |
- void OnIOComplete(BackgroundIO* operation); |
- |
- // Invokes the users' completion callback at the end of the IO operation. |
- // |cancel_task| is true if the actual task posted to the thread is still |
- // queued (because we are inside WaitForPendingIO), and false if said task is |
- // the one performing the call. |
- void InvokeCallback(BackgroundIO* operation, bool cancel_task); |
- |
- private: |
- typedef std::set<scoped_refptr<BackgroundIO> > IOList; |
- |
- IOList io_list_; // List of pending io operations. |
- MessageLoop* callback_thread_; |
-}; |
- |
-// --------------------------------------------------------------------------- |
- |
-// Runs on a worker thread. |
-void BackgroundIO::Read() { |
- if (file_->Read(const_cast<void*>(buf_), buf_len_, offset_)) { |
- bytes_ = static_cast<int>(buf_len_); |
- } else { |
- bytes_ = -1; |
- } |
- controller_->OnIOComplete(this); |
+// Runs on the primary thread. |
+void BackgroundIO::OnIOSignalled() { |
+ if (controller_) |
+ controller_->InvokeCallback(this, false); |
} |
-int BackgroundIO::Result() { |
- return bytes_; |
-} |
- |
void BackgroundIO::Cancel() { |
DCHECK(controller_); |
controller_ = NULL; |
} |
-// Runs on a worker thread. |
-void BackgroundIO::Write(bool delete_buffer) { |
- bool rv = file_->Write(buf_, buf_len_, offset_); |
- if (delete_buffer) { |
- // TODO(rvargas): remove or update this code. |
- delete[] reinterpret_cast<const char*>(buf_); |
- } |
- |
- bytes_ = rv ? static_cast<int>(buf_len_) : -1; |
+// Runs on the background thread. |
+void BackgroundIO::NotifyController() { |
controller_->OnIOComplete(this); |
} |
-// Runs on the IO thread. |
-void BackgroundIO::OnIOSignalled() { |
- if (controller_) |
- controller_->InvokeCallback(this, false); |
-} |
- |
// --------------------------------------------------------------------------- |
-void InFlightIO::PostRead(disk_cache::File *file, void* buf, size_t buf_len, |
- size_t offset, disk_cache::FileIOCallback *callback) { |
- scoped_refptr<BackgroundIO> operation = |
- new BackgroundIO(file, buf, buf_len, offset, callback, this); |
- io_list_.insert(operation.get()); |
- file->AddRef(); // Balanced on InvokeCallback() |
- |
- WorkerPool::PostTask(FROM_HERE, |
- NewRunnableMethod(operation.get(), &BackgroundIO::Read), |
- true); |
-} |
- |
-void InFlightIO::PostWrite(disk_cache::File* file, const void* buf, |
- size_t buf_len, size_t offset, |
- disk_cache::FileIOCallback* callback, |
- bool delete_buffer) { |
- scoped_refptr<BackgroundIO> operation = |
- new BackgroundIO(file, buf, buf_len, offset, callback, this); |
- io_list_.insert(operation.get()); |
- file->AddRef(); // Balanced on InvokeCallback() |
- |
- WorkerPool::PostTask(FROM_HERE, |
- NewRunnableMethod(operation.get(), &BackgroundIO::Write, |
- delete_buffer), |
- true); |
-} |
- |
void InFlightIO::WaitForPendingIO() { |
while (!io_list_.empty()) { |
// Block the current thread until all pending IO completes. |
@@ -221,159 +34,40 @@ |
} |
} |
-// Runs on a worker thread. |
+// Runs on a background thread. |
void InFlightIO::OnIOComplete(BackgroundIO* operation) { |
+#ifndef NDEBUG |
+ if (callback_thread_ == MessageLoop::current()) { |
+ DCHECK(single_thread_ || !running_); |
+ single_thread_ = true; |
+ } |
+ running_ = true; |
+#endif |
+ |
callback_thread_->PostTask(FROM_HERE, |
NewRunnableMethod(operation, |
&BackgroundIO::OnIOSignalled)); |
operation->io_completed()->Signal(); |
} |
-// Runs on the IO thread. |
+// Runs on the primary thread. |
void InFlightIO::InvokeCallback(BackgroundIO* operation, bool cancel_task) { |
operation->io_completed()->Wait(); |
if (cancel_task) |
operation->Cancel(); |
- disk_cache::FileIOCallback* callback = operation->callback(); |
- int bytes = operation->Result(); |
- |
- // Release the references acquired in PostRead / PostWrite. |
- operation->file()->Release(); |
+ // Make sure that we remove the operation from the list before invoking the |
+ // callback (so that a subsequent cancel does not invoke the callback again). |
+ DCHECK(io_list_.find(operation) != io_list_.end()); |
io_list_.erase(operation); |
- callback->OnFileIOComplete(bytes); |
+ OnOperationComplete(operation, cancel_task); |
} |
-} // namespace |
- |
-namespace disk_cache { |
- |
-File::File(base::PlatformFile file) |
- : init_(true), mixed_(true), platform_file_(file) { |
+// Runs on the primary thread. |
+void InFlightIO::OnOperationPosted(BackgroundIO* operation) { |
+ DCHECK(callback_thread_ == MessageLoop::current()); |
+ io_list_.insert(operation); |
} |
-bool File::Init(const FilePath& name) { |
- if (init_) |
- return false; |
- |
- int flags = base::PLATFORM_FILE_OPEN | |
- base::PLATFORM_FILE_READ | |
- base::PLATFORM_FILE_WRITE; |
- platform_file_ = base::CreatePlatformFile(name, flags, NULL); |
- if (platform_file_ < 0) { |
- platform_file_ = 0; |
- return false; |
- } |
- |
- init_ = true; |
- return true; |
-} |
- |
-File::~File() { |
- if (platform_file_) |
- close(platform_file_); |
-} |
- |
-base::PlatformFile File::platform_file() const { |
- return platform_file_; |
-} |
- |
-bool File::IsValid() const { |
- if (!init_) |
- return false; |
- return (base::kInvalidPlatformFileValue != platform_file_); |
-} |
- |
-bool File::Read(void* buffer, size_t buffer_len, size_t offset) { |
- DCHECK(init_); |
- if (buffer_len > ULONG_MAX || offset > LONG_MAX) |
- return false; |
- |
- int ret = pread(platform_file_, buffer, buffer_len, offset); |
- return (static_cast<size_t>(ret) == buffer_len); |
-} |
- |
-bool File::Write(const void* buffer, size_t buffer_len, size_t offset) { |
- DCHECK(init_); |
- if (buffer_len > ULONG_MAX || offset > ULONG_MAX) |
- return false; |
- |
- int ret = pwrite(platform_file_, buffer, buffer_len, offset); |
- return (static_cast<size_t>(ret) == buffer_len); |
-} |
- |
-// We have to increase the ref counter of the file before performing the IO to |
-// prevent the completion to happen with an invalid handle (if the file is |
-// closed while the IO is in flight). |
-bool File::Read(void* buffer, size_t buffer_len, size_t offset, |
- FileIOCallback* callback, bool* completed) { |
- DCHECK(init_); |
- if (!callback) { |
- if (completed) |
- *completed = true; |
- return Read(buffer, buffer_len, offset); |
- } |
- |
- if (buffer_len > ULONG_MAX || offset > ULONG_MAX) |
- return false; |
- |
- InFlightIO* io_operations = Singleton<InFlightIO>::get(); |
- io_operations->PostRead(this, buffer, buffer_len, offset, callback); |
- |
- *completed = false; |
- return true; |
-} |
- |
-bool File::Write(const void* buffer, size_t buffer_len, size_t offset, |
- FileIOCallback* callback, bool* completed) { |
- DCHECK(init_); |
- if (!callback) { |
- if (completed) |
- *completed = true; |
- return Write(buffer, buffer_len, offset); |
- } |
- |
- return AsyncWrite(buffer, buffer_len, offset, true, callback, completed); |
-} |
- |
-bool File::PostWrite(const void* buffer, size_t buffer_len, size_t offset) { |
- DCHECK(init_); |
- return AsyncWrite(buffer, buffer_len, offset, false, NULL, NULL); |
-} |
- |
-bool File::AsyncWrite(const void* buffer, size_t buffer_len, size_t offset, |
- bool notify, FileIOCallback* callback, bool* completed) { |
- DCHECK(init_); |
- if (buffer_len > ULONG_MAX || offset > ULONG_MAX) |
- return false; |
- |
- InFlightIO* io_operations = Singleton<InFlightIO>::get(); |
- io_operations->PostWrite(this, buffer, buffer_len, offset, callback, !notify); |
- |
- if (completed) |
- *completed = false; |
- return true; |
-} |
- |
-bool File::SetLength(size_t length) { |
- DCHECK(init_); |
- if (length > ULONG_MAX) |
- return false; |
- |
- return 0 == ftruncate(platform_file_, length); |
-} |
- |
-size_t File::GetLength() { |
- DCHECK(init_); |
- size_t ret = lseek(platform_file_, 0, SEEK_END); |
- return ret; |
-} |
- |
-// Static. |
-void File::WaitForPendingIO(int* num_pending_io) { |
- if (*num_pending_io) |
- Singleton<InFlightIO>::get()->WaitForPendingIO(); |
-} |
- |
} // namespace disk_cache |