Http cache: Convert data writes from sysnchronous to asynchronous....

net/http/http_cache.cc

 // Copyright (c) 2006-2009 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/http/http_cache.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/compiler_specific.h"
@@ skipping 174 matching lines @@
         truncated_(false),
         read_offset_(0),
         effective_load_flags_(0),
         final_upload_progress_(0),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_info_callback_(this, &Transaction::OnNetworkInfoAvailable)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_read_callback_(this, &Transaction::OnNetworkReadCompleted)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             cache_read_callback_(new CancelableCompletionCallback<Transaction>(
-                this, &Transaction::OnCacheReadCompleted))) {
+                this, &Transaction::OnCacheReadCompleted))),
+        ALLOW_THIS_IN_INITIALIZER_LIST(
+            cache_write_callback_(new CancelableCompletionCallback<Transaction>(
+                this, &Transaction::OnCacheWriteCompleted))) {
   }
 
   // Clean up the transaction.
   virtual ~Transaction();
 
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo*, CompletionCallback*, LoadLog*);
   virtual int RestartIgnoringLastError(CompletionCallback*);
   virtual int RestartWithCertificate(X509Certificate* client_cert,
                                      CompletionCallback* callback);
@@ skipping 120 matching lines @@
   int ReadFromNetwork(IOBuffer* data, int data_len);
 
   // Reads data from the cache entry.
   int ReadFromEntry(IOBuffer* data, int data_len);
 
   // Called to populate response_ from the cache entry.
   int ReadResponseInfoFromEntry();
 
   // Called to write data to the cache entry.  If the write fails, then the
   // cache entry is destroyed.  Future calls to this function will just do
-  // nothing without side-effect.
-  void WriteToEntry(int index, int offset, IOBuffer* data, int data_len);
+  // nothing without side-effect.  Returns a network error code.
+  int WriteToEntry(int index, int offset, IOBuffer* data, int data_len,
+                   CompletionCallback* callback);
 
   // Called to write response_ to the cache entry. |truncated| indicates if the
   // entry should be marked as incomplete.
   void WriteResponseInfoToEntry(bool truncated);
 
-  // Called to append response data to the cache entry.
-  void AppendResponseDataToEntry(IOBuffer* data, int data_len);
+  // Called to append response data to the cache entry.  Returns a network error
+  // code.
+  int AppendResponseDataToEntry(IOBuffer* data, int data_len,
+                                CompletionCallback* callback);
 
   // Called to truncate response content in the entry.
   void TruncateResponseData();
 
   // Called when we are done writing to the cache entry.
   void DoneWritingToEntry(bool success);
 
   // Deletes the current partial cache entry (sparse), and optionally removes
   // the control object (partial_).
   void DoomPartialEntry(bool delete_object);
 
   // Performs the needed work after receiving data from the network.
   int DoNetworkReadCompleted(int result);
 
   // Performs the needed work after receiving data from the network, when
   // working with range requests.
   int DoPartialNetworkReadCompleted(int result);
 
   // Performs the needed work after receiving data from the cache.
   int DoCacheReadCompleted(int result);
 
   // Performs the needed work after receiving data from the cache, when
   // working with range requests.
   int DoPartialCacheReadCompleted(int result);
 
+  // Performs the needed work after writing data to the cache.
+  int DoCacheWriteCompleted(int result);
+
   // Called to signal completion of the network transaction's Start method:
   void OnNetworkInfoAvailable(int result);
 
   // Called to signal completion of the network transaction's Read method:
   void OnNetworkReadCompleted(int result);
 
   // Called to signal completion of the cache's ReadData method:
   void OnCacheReadCompleted(int result);
 
+  // Called to signal completion of the cache's WriteData method:
+  void OnCacheWriteCompleted(int result);
+
   scoped_refptr<LoadLog> load_log_;
   const HttpRequestInfo* request_;
   scoped_ptr<HttpRequestInfo> custom_request_;
   // If extra_headers specified a "if-modified-since" or "if-none-match",
   // |external_validation_| contains the value of that header.
   ValidationHeader external_validation_;
   HttpCache* cache_;
   HttpCache::ActiveEntry* entry_;
   scoped_ptr<HttpTransaction> network_trans_;
   CompletionCallback* callback_;  // Consumer's callback.
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   std::string cache_key_;
   Mode mode_;
   bool reading_;  // We are already reading.
   bool invalid_range_;  // We may bypass the cache for this request.
   bool enable_range_support_;
   bool truncated_;  // We don't have all the response data.
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
   int read_offset_;
   int effective_load_flags_;
   scoped_ptr<PartialData> partial_;  // We are dealing with range requests.
   uint64 final_upload_progress_;
   CompletionCallbackImpl<Transaction> network_info_callback_;
   CompletionCallbackImpl<Transaction> network_read_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> >
       cache_read_callback_;
+  scoped_refptr<CancelableCompletionCallback<Transaction> >
+      cache_write_callback_;
 };
 
 HttpCache::Transaction::~Transaction() {
   if (!revoked()) {
     if (entry_) {
       bool cancel_request = reading_ && enable_range_support_;
       if (cancel_request && !partial_.get())
         cancel_request &= (response_.headers->response_code() == 200);
 
       cache_->DoneWithEntry(entry_, this, cancel_request);
     } else {
       cache_->RemovePendingTransaction(this);
     }
   }
 
   // If there is an outstanding callback, mark it as cancelled so running it
   // does nothing.
   cache_read_callback_->Cancel();
+  cache_write_callback_->Cancel();
 
-  // We could still have a cache read in progress, so we just null the cache_
-  // pointer to signal that we are dead.  See OnCacheReadCompleted.
+  // We could still have a cache read or write in progress, so we just null the
+  // cache_ pointer to signal that we are dead.  See DoCacheReadCompleted.
   cache_ = NULL;
 }
 
 int HttpCache::Transaction::Start(const HttpRequestInfo* request,
                                   CompletionCallback* callback,
                                   LoadLog* load_log) {
   DCHECK(request);
   DCHECK(callback);
 
   // ensure that we only have one asynchronous call at a time.
@@ skipping 827 matching lines @@
   read_buf_ = data;
   read_buf_len_ = data_len;
   if (rv >= 0)
     rv = DoNetworkReadCompleted(rv);
   return rv;
 }
 
 int HttpCache::Transaction::ReadFromEntry(IOBuffer* data, int data_len) {
   DCHECK(entry_);
   int rv;
-  cache_read_callback_->AddRef();  // Balanced in DoCacheReadCompleted.
+  cache_read_callback_->AddRef();  // Balanced in OnCacheReadCompleted.
   if (partial_.get()) {
     rv = partial_->CacheRead(entry_->disk_entry, data, data_len,
                             cache_read_callback_);
   } else {
     rv = entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
                                       data, data_len, cache_read_callback_);
   }
   read_buf_ = data;
   read_buf_len_ = data_len;
-  if (rv >= 0) {
+  if (rv != ERR_IO_PENDING)
+    cache_read_callback_->Release();
+
+  if (rv >= 0)
     rv = DoCacheReadCompleted(rv);
-  } else if (rv != ERR_IO_PENDING) {
-    cache_read_callback_->Release();
-  }
+
   return rv;
 }
 
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
   LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_READ_INFO);
   bool read_ok =
       HttpCache::ReadResponseInfo(entry_->disk_entry, &response_, &truncated_);
   LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_READ_INFO);
 
   return read_ok ? OK : ERR_CACHE_READ_FAILURE;
 }
 
-void HttpCache::Transaction::WriteToEntry(int index, int offset,
-                                          IOBuffer* data, int data_len) {
+int HttpCache::Transaction::WriteToEntry(int index, int offset,
+                                         IOBuffer* data, int data_len,
+                                         CompletionCallback* callback) {
   if (!entry_)
-    return;
+    return data_len;
 
   int rv = 0;
   if (!partial_.get() || !data_len) {
-    rv = entry_->disk_entry->WriteData(index, offset, data, data_len, NULL,
+    rv = entry_->disk_entry->WriteData(index, offset, data, data_len, callback,
                                        true);
   } else {
-    rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, NULL);
+    rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, callback);
   }
-  if (rv != data_len) {
+
+  if (rv >= 0 && rv != data_len) {
     DLOG(ERROR) << "failed to write response data to cache";
     DoneWritingToEntry(false);
   }
+  return rv;
 }
 
 void HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) {
   if (!entry_)
     return;
 
   // Do not cache no-store content (unless we are record mode).  Do not cache
   // content with cert errors either.  This is to prevent not reporting net
   // errors when loading a resource from the cache.  When we load a page over
   // HTTPS with a cert error we show an SSL blocking page.  If the user clicks
@@ skipping 17 matching lines @@
     DCHECK_EQ(200, response_.headers->response_code());
   }
 
   if (!HttpCache::WriteResponseInfo(entry_->disk_entry, &response_,
                                     skip_transient_headers, truncated)) {
     DLOG(ERROR) << "failed to write response info to cache";
     DoneWritingToEntry(false);
   }
 }
 
-void HttpCache::Transaction::AppendResponseDataToEntry(IOBuffer* data,
-                                                       int data_len) {
+int HttpCache::Transaction::AppendResponseDataToEntry(
+    IOBuffer* data, int data_len, CompletionCallback* callback) {
   if (!entry_ || !data_len)
-    return;
+    return data_len;
 
   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
-  WriteToEntry(kResponseContentIndex, current_size, data, data_len);
+  return WriteToEntry(kResponseContentIndex, current_size, data, data_len,
+                      callback);
 }
 
 void HttpCache::Transaction::TruncateResponseData() {
   if (!entry_)
     return;
 
   // Truncate the stream.
-  WriteToEntry(kResponseContentIndex, 0, NULL, 0);
+  int rv = WriteToEntry(kResponseContentIndex, 0, NULL, 0, NULL);
+  DCHECK(rv != ERR_IO_PENDING);
 }
 
 void HttpCache::Transaction::DoneWritingToEntry(bool success) {
   if (!entry_)
     return;
 
   if (cache_->mode() == RECORD)
     DLOG(INFO) << "Recorded: " << request_->method << request_->url
                << " status: " << response_.headers->response_code();
 
   cache_->DoneWritingToEntry(entry_, success);
   entry_ = NULL;
   mode_ = NONE;  // switch to 'pass through' mode
 }
 
 void HttpCache::Transaction::DoomPartialEntry(bool delete_object) {
   cache_->DoneWithEntry(entry_, this, false);
   cache_->DoomEntry(cache_key_);
   entry_ = NULL;
   if (delete_object)
     partial_.reset(NULL);
 }
 
 int HttpCache::Transaction::DoNetworkReadCompleted(int result) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
   if (revoked())
     return HandleResult(ERR_UNEXPECTED);
 
-  AppendResponseDataToEntry(read_buf_, result);
+  cache_write_callback_->AddRef();  // Balanced in DoCacheWriteCompleted.
 
-  if (partial_.get())
-    return DoPartialNetworkReadCompleted(result);
+  result = AppendResponseDataToEntry(read_buf_, result, cache_write_callback_);
+  if (result == ERR_IO_PENDING)
+    return result;
 
-  if (result == 0)  // End of file.
-    DoneWritingToEntry(true);
-
-  return HandleResult(result);
+  return DoCacheWriteCompleted(result);
 }
 
 int HttpCache::Transaction::DoPartialNetworkReadCompleted(int result) {
   partial_->OnNetworkReadCompleted(result);
 
   if (result == 0) {  // End of file.
     if (mode_ == READ_WRITE) {
       // We need to move on to the next range.
       network_trans_.reset();
       result = ContinuePartialCacheValidation();
       if (result != OK)
         // Any error was already handled.
         return result;
     }
     DoneWritingToEntry(true);
   }
   return HandleResult(result);
 }
 
 int HttpCache::Transaction::DoCacheReadCompleted(int result) {
   DCHECK(cache_);
-  cache_read_callback_->Release();  // Balance the AddRef() from Start().
 
   if (revoked())
     return HandleResult(ERR_UNEXPECTED);
 
   if (partial_.get())
     return DoPartialCacheReadCompleted(result);
 
   if (result > 0) {
     read_offset_ += result;
   } else if (result == 0) {  // End of file.
@@ skipping 14 matching lines @@
         // Any error was already handled.
         return result;
       cache_->ConvertWriterToReader(entry_);
     }
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   }
   return HandleResult(result);
 }
 
+int HttpCache::Transaction::DoCacheWriteCompleted(int result) {
+  DCHECK(cache_);
+  // Balance the AddRef from DoNetworkReadCompleted.
+  cache_write_callback_->Release();
+  if (revoked())
+    return HandleResult(ERR_UNEXPECTED);
+
+  if (result < 0)
+    return HandleResult(result);
+
+  if (partial_.get())
+    return DoPartialNetworkReadCompleted(result);
+
+  if (result == 0)  // End of file.
+    DoneWritingToEntry(true);
+
+  return HandleResult(result);
+}
+
 void HttpCache::Transaction::OnNetworkInfoAvailable(int result) {
   DCHECK(result != ERR_IO_PENDING);
 
   if (revoked()) {
     HandleResult(ERR_UNEXPECTED);
     return;
   }
 
   if (result == OK) {
     const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
@@ skipping 94 matching lines @@
     response_.cert_request_info = response->cert_request_info;
   }
   HandleResult(result);
 }
 
 void HttpCache::Transaction::OnNetworkReadCompleted(int result) {
   DoNetworkReadCompleted(result);
 }
 
 void HttpCache::Transaction::OnCacheReadCompleted(int result) {
+  cache_read_callback_->Release();  // Balance the AddRef from ReadFromEntry.
   DoCacheReadCompleted(result);
 }
 
+void HttpCache::Transaction::OnCacheWriteCompleted(int result) {
+  DoCacheWriteCompleted(result);
+}
+
 //-----------------------------------------------------------------------------
 
 HttpCache::HttpCache(HostResolver* host_resolver,
                      ProxyService* proxy_service,
                      SSLConfigService* ssl_config_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
@@ skipping 534 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net