Disk cache: Extend the internal buffering performed by each entry...

net/disk_cache/file_posix.cc

 // Copyright (c) 2006-2008 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 <fcntl.h>
 
 #include <set>
 
@@ skipping 19 matching lines @@
   // 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,
+  // the object. 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);
+  void Write();
 
   // 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.
@@ skipping 59 matching lines @@
  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);
+                 size_t offset, disk_cache::FileIOCallback* callback);
 
   // 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
@@ skipping 23 matching lines @@
 int BackgroundIO::Result() {
   return bytes_;
 }
 
 void BackgroundIO::Cancel() {
   DCHECK(controller_);
   controller_ = NULL;
 }
 
 // Runs on a worker thread.
-void BackgroundIO::Write(bool delete_buffer) {
+void BackgroundIO::Write() {
   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;
   controller_->OnIOComplete(this);
 }
 
 // Runs on the IO thread.
 void BackgroundIO::OnIOSignalled() {
   if (controller_)
     controller_->InvokeCallback(this, false);
 }
@@ skipping 10 matching lines @@
   if (!callback_thread_)
       callback_thread_ = MessageLoop::current();
 
   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) {
+                           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()
 
   if (!callback_thread_)
     callback_thread_ = MessageLoop::current();
 
   WorkerPool::PostTask(FROM_HERE,
-                       NewRunnableMethod(operation.get(), &BackgroundIO::Write,
-                                         delete_buffer),
+                       NewRunnableMethod(operation.get(), &BackgroundIO::Write),
                        true);
 }
 
 void InFlightIO::WaitForPendingIO() {
   while (!io_list_.empty()) {
     // Block the current thread until all pending IO completes.
     IOList::iterator it = io_list_.begin();
     InvokeCallback(*it, true);
   }
   // Unit tests can use different threads.
@@ skipping 106 matching lines @@
 
 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);
+  return AsyncWrite(buffer, buffer_len, offset, callback, completed);
 }
 
 bool File::AsyncWrite(const void* buffer, size_t buffer_len, size_t offset,
-                      bool notify, FileIOCallback* callback, bool* completed) {
+                      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);
+  io_operations->PostWrite(this, buffer, buffer_len, offset, callback);
 
   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) {
   // We may be running unit tests so we should allow InFlightIO to reset the
   // message loop.
   Singleton<InFlightIO>::get()->WaitForPendingIO();
 }
 
 }  // namespace disk_cache